Recommit changing List.skip/take/revert returns Iterable and remove mappedBy.

sdk/lib/async/future_impl.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;
 
 deprecatedFutureValue(_FutureImpl future) =>
   future._isComplete ? future._resultOrListeners : null;
 
 
@@ skipping 93 matching lines @@
   _FutureImpl.immediateError(var error, [Object stackTrace]) {
     AsyncError asyncError;
     if (error is AsyncError) {
       asyncError = error;
     } else {
       asyncError = new AsyncError(error, stackTrace);
     }
     _setError(asyncError);
   }
 
   factory _FutureImpl.wait(Iterable<Future> futures) {

[Lasse Reichstein Nielsen, 2013/02/18 09:59:29]

This implementation of wait is slightly safer than the previous one: It only
runs through the iterable once.
If using a non-list-based iterable, the previous version would run through it
twice (twice(!) to get the length, once to get values), and if the iterator had
side effects (A list.map(f) with f having side effects) that would not work as
expected.

-    // TODO(ajohnsen): can we do better wrt. the generic type T?
-    if (futures.isEmpty) {
-      return new Future<List>.immediate(const []);
+    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.error, error.stackTrace);
+      }
     }
-
-    Completer completer = new Completer<List>();
-    int remaining = futures.length;
-    List values = new List.fixedLength(futures.length);
-
     // As each future completes, put its value into the corresponding
     // position in the list of values.
-    int i = 0;
-    bool completed = false;
+    int remaining = 0;
     for (Future future in futures) {
-      int pos = i++;
-      future.then((Object value) {
+      int pos = remaining++;
+      future.catchError(handleError).then((Object value) {
+        if (values == null) return null;
         values[pos] = value;
-        if (--remaining == 0) {
+        remaining--;
+        if (remaining == 0) {
           completer.complete(values);
         }
-      }).catchError((error) {
-        if (!completed) completer.completeError(error.error, error.stackTrace);
-        completed = true;
       });
     }
-
+    if (remaining == 0) {
+      return new Future.immediate(const []);
+    }
+    values = new List.fixedLength(remaining);
+    completer = new Completer<List>();
     return completer.future;
   }
 
   Future then(f(T value), { onError(AsyncError error) }) {
     if (!_isComplete) {
       if (onError == null) {
         return new _ThenFuture(f).._subscribeTo(this);
       }
       return new _SubscribeFuture(f, onError).._subscribeTo(this);
     }
@@ skipping 370 matching lines @@
   Future catchError(function(AsyncError error), {bool test(var error)}) {
     return _future.catchError(function, test: test);
   }
 
   Future<T> whenComplete(action()) {
     return _future.whenComplete(action);
   }
 
   Stream<T> asStream() => new Stream.fromFuture(_future);
 }