Remove Futures class, move methods to Future.

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] 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:
  *
@@ skipping 18 matching lines @@
  */
 abstract class Future<T> {
   /** A future whose value is immediately available. */
   factory Future.immediate(T value) => new _FutureImpl<T>.immediate(value);
 
   /** A future that completes with an error. */
   factory Future.immediateError(var error, [Object stackTrace]) {
     return new _FutureImpl<T>.immediateError(error, stackTrace);
   }
 
-  factory Future.delayed(int milliseconds, dynamic value()) {
-    var completer = new Completer<T>();
-    new Timer(milliseconds, (_) => completer.complete(null));
-    return completer.future.then((_) => value());
+  /**
+   * Creates a future that completes after a delay.
+   *
+   * The future will be completed after [milliseconds] have passed with
+   * the result of calling [value].
+   *
+   * If calling [value] throws, the created future will complete with the
+   * error.
+   */
+  factory Future.delayed(int milliseconds, T value()) {
+    _FutureImpl<T> future = new _ThenFuture<dynamic, T>((_) => value());
+    new Timer(milliseconds, (_) => future._sendValue(null));
+    return future;
   }
 
-  // TODO(floitsch): I don't think the typing is right here.
-  // Otherwise new Future<int>.wait(...) would be a Future<List<int>>. Sounds
-  // wrong.
-  factory Future.wait(List<Future> futures)
-    => new _FutureImpl<List<T>>.wait(futures);
+  /**
+   * 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) {
+    return new _FutureImpl<List>.wait(futures);
+  }
+
+  /**
+   * 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();
+    Iterator iterator = input.iterator;
+    void nextElement(_) {
+      if (iterator.moveNext()) {
+        f(iterator.current).then(nextElement, onError: doneSignal._setError);
+      } else {
+        doneSignal._setValue(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.
    *
    * 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
@@ skipping 114 matching lines @@
    * 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.
    *
    * Otherwise the [exception] and an optional [stackTrace] is combined into an
    * [AsyncError] and sent to this future's listeners.
    */
   void completeError(Object exception, [Object stackTrace]);
 }
-
-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(Iterable<Future> futures) {
-    return new _FutureImpl<List>.wait(futures);
-  }
-
-  /**
-   * 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)) {
-    var iterator = input.iterator;
-    Future nextElement(_) {
-      if (!iterator.moveNext()) return new Future.immediate(null);
-      return f(iterator.current).then(nextElement);
-    }
-    return nextElement(null);
-  }
-}