Convert most interfaces in dart:core to abstract classes.

lib/core/future.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * A [Future] is used to obtain a value sometime in the future.  Receivers of a
  * [Future] can obtain the value by passing a callback to [then]. For example:
  *
  *     Future<int> future = getFutureFromSomewhere();
  *     future.then((value) {
  *       print("I received the number $value");
  *     });
  *
  * A future may complete by *succeeding* (producing a value) or *failing*
  * (producing an exception, which may be handled with [handleException]).
  * Callbacks passed to [onComplete] will be invoked in either case.
  *
  * When a future completes, the following actions happen in order:
  *
  *   1. if the future suceeded, handlers registered with [then] are called.
  *   2. if the future failed, handlers registered with [handleException] are
  *      called in sequence, until one returns true.
  *   3. handlers registered with [onComplete] are called
  *   4. if the future failed, and at least one handler was registered with
  *      [then], and no handler registered with [handleException] returned
  *      [:true:], then the exception is thrown.
  *
  * Use a [Completer] to create and change the state of a [Future].
  */
-interface Future<T> default FutureImpl<T> {
-
+abstract class Future<T> {
   /** A future whose value is immediately available. */
-  Future.immediate(T value);
+  factory Future.immediate(T value) => new FutureImpl<T>.immediate(value);
 
   /** The value provided. Throws an exception if [hasValue] is false. */
   T get value;
 
   /**
    * Exception that occurred ([:null:] if no exception occured). This property
    * throws a [FutureNotCompleteException] if it is used before this future is
    * completes.
    */
   Object get exception;
@@ skipping 107 matching lines @@
  *     ...
  *
  *     // later when value is available, call:
  *     completer.complete(value);
  *
  *     // alternatively, if the service cannot produce the value, it
  *     // can provide an exception:
  *     completer.completeException(exception);
  *
  */
-interface Completer<T> default CompleterImpl<T> {
+abstract class Completer<T> {
 
-  Completer();
+  factory Completer() => new CompleterImpl<T>();
 
   /** The future that will contain the value produced by this completer. */
   Future get future;
 
   /** Supply a value for [future]. */
   void complete(T value);
 
   /**
    * Indicate in [future] that an exception occured while trying to produce its
    * value. The argument [exception] should not be [:null:]. A [stackTrace]
@@ skipping 17 matching lines @@
   FutureAlreadyCompleteException() {}
   String toString() => "Exception: future already completed";
 }
 
 
 /**
  * [Futures] holds additional utility functions that operate on [Future]s (for
  * example, waiting for a collection of Futures to complete).
  */
 class Futures {
-
   /**
    * 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. (The value of the
    * returned future will be a list of all the values that were produced.)
    */
   static Future<List> wait(List<Future> futures) {
     if (futures.isEmpty()) {
       return new Future<List>.immediate(const []);
     }
@@ skipping 19 matching lines @@
       future.handleException((exception) {
         if (!result.isComplete) {
           completer.completeException(exception, future.stackTrace);
         }
         return true;
       });
     }
     return result;
   }
 }