anchor.diff:     * value. If [this] future is already completed then the invocation of
      * [onValue] is delayed until the next event-loop iteration.
      *
  -   * Returns a new [Future] [:f:].
  -   *
  -   * If [this] is completed with an error then [:f:] is completed with the same
  -   * error. If [this] is completed with a value, then [:f:]'s completion value
  -   * depends on the result of invoking [onValue] with [this]' completion value.
  -   *
  -   * If [onValue] returns a [Future] [:f2:] then [:f:] and [:f2:] are chained.
  -   * That is, [:f:] is completed with the completion value of [:f2:].
  -   *
  -   * Otherwise [:f:] is completed with the return value of [onValue].
  -   *
  -   * If [onValue] throws an exception, the returned future will receive the
  -   * exception. If the value thrown is an [AsyncError], it is used directly,
  -   * as the error result, otherwise it is wrapped in an [AsyncError] first.
  -   *
  -   * If [onError] is provided, it is called if this future completes with an
  -   * error, and its return value/throw behavior is handled the same way as
  -   * for [catchError] without a [:test:] argument.
  +   * Returns a new [Future] `f` which is completed with the result of
  +   * invoking [onValue] (if [this] completes with a value) or [onError] (if
  +   * [this] completes with an error).
  +   *
  +   * If the invoked callback throws an exception, the returned future `f` is
  +   * completed with the error. If the value thrown is an [AsyncError], it is
  +   * used directly, as the error result. Otherwise it is wrapped in an
  +   * [AsyncError] first.
  +   *
  +   * If the invoked callback returns a [Future] `f2` then `f` and `f2` are
  +   * chained. That is, `f` is completed with the completion value of `f2`.
  +   *
  +   * If [onError] is not given, it is equivalent to `(e) { throw e; }`. That
  +   * is, it forwards the error to `f`.
      *
      * In most cases, it is more readable to use [catchError] separately, possibly
  -   * with a [:test:] parameter, instead of handling both value and error in a
  +   * with a `test` parameter, instead of handling both value and error in a
      * single [then] call.
      */
     Future then(onValue(T value), { onError(AsyncError asyncError) });
  
positive.code:    * Wait for all the given futures to complete and collect their values.
     *
     * Returns a future which will complete once all the futures in a list are
     * complete. If any of the futures in the list completes with an exception,
     * the resulting future also completes with an exception. Otherwise the value
     * of the returned future will be a list of all the values that were produced.
     */
    static Future<List> wait(Iterable<Future> futures) {
  
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());
  
  