Rewrite Futures.

sdk/lib/async/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.
 
 part of dart.async;
 
 /**
  * A [Future] represents a delayed computation. It 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
@@ skipping 82 matching lines @@
    * completed with the error. If a thrown value is an [AsyncError], it is used
    * directly, instead of wrapping this error again in another [AsyncError].
    *
    * If the returned value is itself a [Future], completion of
    * the created future will wait until the returned future completes,
    * and will then complete with the same result.
    *
    * If a value is returned, it becomes the result of the created future.
    */
   factory Future(computation()) {
-    _ThenFuture<dynamic, T> future =
-        new _ThenFuture<dynamic, T>((_) => computation());
-    Timer.run(() => future._sendValue(null));
-    return future;
+    Completer completer = new Completer.sync();

[Lasse Reichstein Nielsen, 2013/09/10 12:03:53]

WHy not "new _Future()" followed by ".complete" or ".completeError"?

[floitsch, 2013/09/10 17:19:14]

Done.

+    Timer.run(() {
+      try {
+        completer.complete(computation());
+      } catch (e, s) {
+        completer.completeError(e, s);
+      }
+    });
+    return completer.future;
   }
 
   /**
    * Creates a future containing the result of immediately calling
    * [computation].
    *
    * if the result of executing [computation] throws, the returned future is

[Lasse Reichstein Nielsen, 2013/09/10 12:03:53]

Capital "I".
And reword to "If calling [computation] throws,".

[floitsch, 2013/09/10 17:19:14]

Done.

    * completed with the error. If a thrown value is an [AsyncError], it is used
    * directly, instead of wrapping this error again in another [AsyncError].
    *
    * If the returned value is itself a [Future], completion of
    * the created future will wait until the returned future completes,
    * and will then complete with the same result.
    */
   factory Future.sync(computation()) {
     try {
       var result = computation();
-      return new _FutureImpl<T>().._setOrChainValue(result);
+      return new Future.value(result);
     } catch (error, stackTrace) {
-      return new _FutureImpl<T>.immediateError(error, stackTrace);
+      return new Future.error(error, stackTrace);
     }
   }
 
   /**
    * A future whose value is available in the next event-loop iteration.
    *
    * If [value] is not a [Future], using this constructor is equivalent
    * to [:new Future.sync(() => value):].
    *
    * See [Completer] to create a Future and complete it later.
    */
-  factory Future.value([T value]) => new _FutureImpl<T>.immediate(value);
+  factory Future.value([T value]) {
+    return new _Future<T>.immediate(value);
+  }
 
   /**
    * A future that completes with an error in the next event-loop iteration.
    *
    * See [Completer] to create a Future and complete it later.
    */
   factory Future.error(var error, [Object stackTrace]) {
-    return new _FutureImpl<T>.immediateError(error, stackTrace);
+    return new _Future<T>.immediateError(error, stackTrace);
   }
 
   /**
    * Creates a future that completes after a delay.
    *
    * The future will be completed after the given [duration] has passed with
    * the result of calling [computation]. If the duration is 0 or less, it
    * completes no sooner than in the next event-loop iteration.
    *
    * If [computation] is not given or [:null:] then it will behave as if
    * [computation] was set to [:() => null:]. That is, it will complete with
    * [:null:].
    *
    * If calling [computation] throws, the created future will complete with the
    * error.
    *
    * See [Completer]s, for futures with values that are computed asynchronously.
    */
   factory Future.delayed(Duration duration, [T computation()]) {
-    // TODO(floitsch): no need to allocate a ThenFuture when the computation is
-    // null.
-    if (computation == null) computation = (() => null);
-    _ThenFuture<dynamic, T> future =
-        new _ThenFuture<dynamic, T>((_) => computation());
-    new Timer(duration, () => future._sendValue(null));
-    return future;
+    Completer completer = new Completer.sync();
+    Future result = completer.future;
+    if (computation != null) {
+      result = result.then((ignored) => computation());

[Lasse Reichstein Nielsen, 2013/09/10 12:03:53]

This throws away the type parameter.
Can we avoid using this strategy?

[floitsch, 2013/09/10 17:19:14]

Not now.
We will go through the whole library and decide if we should worry or not.
We are not going to start caring randomly.

+    }
+    new Timer(duration, () { completer.complete(null); });
+    return result;
   }
 
   /**
    * 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 error,
    * the resulting future also completes with an error. 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) {
-    return new _FutureImpl<List>.wait(futures);
+    Completer completer;
+    // List collecting values from the futures.
+    // Set to null if an error occurs.
+    List values;
+    void handleError(error) {
+      if (values != null) {
+        values = null;
+        completer.completeError(error);
+      }
+    }
+    // As each future completes, put its value into the corresponding
+    // position in the list of values.
+    int remaining = 0;
+    for (Future future in futures) {
+      int pos = remaining++;
+      future.catchError(handleError).then((Object value) {
+        if (values == null) return null;
+        values[pos] = value;
+        remaining--;
+        if (remaining == 0) {
+          completer.complete(values);
+        }
+      });
+    }
+    if (remaining == 0) {
+      return new Future.value(const []);
+    }
+    values = new List(remaining);
+    completer = new Completer<List>();
+    return completer.future;
   }
 
   /**
    * Perform an async operation for each element of the iterable, in turn.
    *
    * Runs [f] for each element in [input] in order, moving to the next element
    * only when the [Future] returned by [f] completes. Returns a [Future] that
    * completes when all elements have been processed.
    *
    * The return values of all [Future]s are discarded. Any errors will cause the
    * iteration to stop and will be piped through the returned [Future].
    */
   static Future forEach(Iterable input, Future f(element)) {
-    _FutureImpl doneSignal = new _FutureImpl();
+    _Future doneSignal = new _Future();
     Iterator iterator = input.iterator;
     void nextElement(_) {
       if (iterator.moveNext()) {
         new Future.sync(() => f(iterator.current))
-            .then(nextElement, onError: doneSignal._setError);
+            .then(nextElement, onError: doneSignal._completeError);
       } else {
-        doneSignal._setValue(null);
+        doneSignal._complete(null);
       }
     }
     nextElement(null);
     return doneSignal;
   }
 
   /**
    * When this future completes with a value, then [onValue] is called with this
    * value. If [this] future is already completed then the invocation of
    * [onValue] is delayed until the next event-loop iteration.
@@ skipping 202 matching lines @@
    *
    * The argument [exception] must not be `null`.
    */
   void completeError(Object exception, [Object stackTrace]);
 
   /**
    * Whether the future has been completed.
    */
   bool get isCompleted;
 }