anchor.diff:  part of dart.async;
   
   /**
  - * A [Future] represents a delayed computation. It is used to obtain a not-yet
  + * An object representing a delayed computation.
  + *
  + * A [Future] is used to obtain a not yet
    * available value, or error, sometime in the future.  Receivers of a
    * [Future] can register callbacks that handle the value or error once it is
    * available. For example:
  
positive.code:  *         _completer.completeError(error);
   *       }
   *     }
   *
   */
  abstract class Completer<T> {
  
  
negative.code: }
  
  /**
   * A way to produce Future objects and to complete them later
   * with a value or error.
   *
   * If you already have a Future, you probably don't need a Completer.
   * Instead, you can usually use [Future.then], which returns a Future:
   * 
   *     Future doStuff(){
   *       return someAsyncOperation().then((result) {
   *         // Do something.
   *       });
   *     }
   *
   * If you do need to create a Future from scratch—for example,
   * when you're converting a callback-based API into a Future-based
   * one—you can use a Completer as follows:
   *
   *     Class AsyncOperation {
   *       Completer _completer = new Completer();
   *
   *       Future<T> doOperation() {
   *         _startOperation();
   *         return _completer.future; // Send future object back to client.
   *       }
   *
   *       // Something calls this when the value is ready.
   *       _finishOperation(T result) {
   *         _completer.complete(result);
   *       }
   *
   *       // If something goes wrong, call this.
  