Rename runAsync to scheduleMicrotask.

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;
 
 /**
  * An object representing a delayed computation.
  *
  * A [Future] is used to obtain a not yet
@@ skipping 73 matching lines @@
  * Futures can have more than one callback-pairs registered. Each successor is
  * treated independently and is handled as if it was the only successor.
  */
 // TODO(floitsch): document chaining.
 abstract class Future<T> {
 
   /**
    * Creates a future containing the result of calling [computation]
    * asynchronously with [Timer.run].
    *
-   * if the result of executing [computation] throws, the returned future is
-   * 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 result of executing [computation] throws, the returned future is
+   * completed with the error.
    *
    * 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()) {
     _Future result = new _Future<T>();
     Timer.run(() {
       try {
         result._complete(computation());
       } catch (e, s) {
         result._completeError(e, s);
       }
     });
     return result;
   }
 
   /**
+   * Creates a future containing the result of calling [computation]
+   * asynchronously with [scheduleMicrotask].
+   *
+   * If the result of executing [computation] throws, the returned future is
+   * completed with the error.
+   *
+   * 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.microtask(computation()) {
+    _Future result = new _Future<T>();
+    scheduleMicrotask(() {
+      try {
+        result._complete(computation());
+      } catch (e, s) {
+        result._completeError(e, s);
+      }
+    });
+    return result;
+  }
+
+  /**
    * Creates a future containing the result of immediately calling
    * [computation].
    *
    * If calling [computation] throws, the returned future is completed with the
-   * error. If a thrown value is an [AsyncError], it is used
-   * directly, instead of wrapping this error again in another [AsyncError].
+   * error.
    *
    * 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 Future<T>.value(result);
     } catch (error, stackTrace) {
@@ skipping 343 matching lines @@
    *
    * The argument [exception] must not be `null`.
    */
   void completeError(Object exception, [Object stackTrace]);
 
   /**
    * Whether the future has been completed.
    */
   bool get isCompleted;
 }