anchor.diff:    /**
      * Handles errors emitted by this [Future].
      *
  -   * When this future completes with an error, first [test] is called with the
  -   * error's value.
  -   *
  -   * If [test] returns [true], [onError] is called with the error
  -   * wrapped in an [AsyncError]. The result of [onError] is handled exactly as
  -   * [then]'s [onValue].
  +   * Returns a new [Future] `f`.
  +   *
  +   * When [this] completes with a value, the value is forwarded to `f`
  +   * unmodified. That is, `f` completes with the same value.
  +   *
  +   * When [this] completes with an error, [test] is called with the
  +   * error's value. If the invocation returns [true], [onError] is called with
  +   * the error wrapped in an [AsyncError]. The result of [onError] is handled
  +   * exactly the same as for [then]'s [onError].
      *
      * If [test] returns false, the exception is not handled by [onError], but is
  -   * emitted by the returned Future unmodified.
  +   * thrown unmodified, thus forwarding it to `f`.
      *
      * If [test] is omitted, it defaults to a function that always returns true.
      *
      * Example:
  -   * foo
  -   *   .catchError(..., test: (e) => e is ArgumentError)
  -   *   .catchError(..., test: (e) => e is NoSuchMethodError)
  -   *   .then((v) { ... });
  +   *
  +   *     foo
  +   *       .catchError(..., test: (e) => e is ArgumentError)
  +   *       .catchError(..., test: (e) => e is NoSuchMethodError)
  +   *       .then((v) { ... });
  +   *
  +   * This method is equivalent to:
  +   *
  +   *     Future catchError(onError(AsyncError asyncError),
  +   *                       {bool test(Object error)}) {
  +   *       this.then((v) => v,  // Forward the value.
  +   *                 // But handle errors, if the [test] succeeds.
  +   *                 onError: (AsyncError e) {
  +   *                   if (test == null || test(e.error)) {
  +   *                     return onError(e);
  +   *                   }
  +   *                   throw e;
  +   *                 });
  +   *     }
  +   *
      */
     Future catchError(onError(AsyncError asyncError),
                       {bool test(Object error)});
  
positive.code:    * Completing a future with an error indicates that an exception was thrown
     * while trying to produce a value.
     *
     * The argument [exception] should not be [:null:].
     *
     * If [exception] is an [AsyncError], it is used directly as the error
     * message sent to the future's listeners, and [stackTrace] is ignored.
  
negative.code:    *
     * This is the asynchronous equivalent of a "finally" block.
     *
     * The future returned by this call, `f`, will complete the same way
     * as this future unless an error occurs in the [action] call, or in
     * a [Future] returned by the [action] call. If the call to [action]
     * does not return a future, its return value is ignored.
     *
     * If the call to [action] throws, then `f` is completed with the
     * thrown error.
     *
     * If the call to [action] returns a [Future], `f2`, then completion of
     * `f` is delayed until `f2` completes. If `f2` completes with
     * an error, that will be the result of `f` too.
     *
     * This method is equivalent to:
     *
     *     Future<T> whenComplete(action()) {
     *       this.then((v) {
     *                   action();
     *                   return v
     *                 },
     *                 onError: (AsyncError e) {
     *                   action();
     *                   throw e;
     *                 });
     *     }
     */
    Future<T> whenComplete(action());
  
  