patch from issue 9360020

corelib/src/future.dart

 // Copyright (c) 2011, 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.
 
 // Dart core library.
 
 
 /**
  * A Future is used to obtain a value sometime in the
  * future.
  *
  * Receivers of a Future obtain the value by passing
  * a callback to the 'then' method of Future.
  *
  * For example:
  *
  *   Future<int> future = getFutureFromSomewhere();
  *   future.then((value) {
  *     print("I received the number " + value);
  *   });
  *
  */
 interface Future<T> default FutureImpl<T> {
+  /** A future whose value is immediately available. */
+  Future.immediate(T value);
 
   /**
    * The value this future provided.  (If called when hasValue
    * is false, then throws an exception.)
    */
   T get value();
 
   /**
    * Exception that occurred (null if no exception occured).  (If called
    * before [isComplete] is true, then this exception property itself
@@ skipping 30 matching lines @@
    * any calls to [then] (meaning that there are onComplete callbacks waiting
    * for the value), then the exception will be thrown when it is set.
    *
    * (In most cases it should not be necessary to call handleException,
    * because the exception associated with this Future will propagate naturally
    * if the future's value is being consumed.  Only call handleException if you
    * need to do some special local exception handling related to this
    * particular Future's value.)
    */
   void handleException(bool onException(Object exception));
+
+  /**
+   * A future representing [transformation] applied to this future's value.
+   *
+   * When this future gets a value, [transformation] will be called on the
+   * value, and the returned future will receive the result.
+   *
+   * If an exception occurs (received by this future, or thrown by
+   * [transformation]) then the returned future will receive the exception.
+   *
+   * You must not add exception handlers to [this] future prior to calling
+   * transform, and any you add afterwards will not be invoked.
+   */
+  Future transform(Function transformation);
+
+   /**
+    * A future representing an asynchronous transformation applied to this
+    * future's value. [transformation] must return a Future.
+    *
+    * When this future gets a value, [transformation] will be called on the
+    * value. When the resulting future gets a value, the returned future
+    * will receive it.
+    *
+    * If an exception occurs (received by this future, thrown by
+    * [transformation], or received by the future returned by [transformation])
+    * then the returned future will receive the exception.
+    *
+    * You must not add exception handlers to [this] future prior to calling
+    * chain, and any you add afterwards will not be invoked.
+    */
+   Future chain(Function transformation);
 }
 
 
 /**
  * A Completer is used to produce Future objects, and supply
  * a value to the Future object when the value becomes available.
  *
  * A service that provides values to callers, and wants to return Future objects
  * rather than returning the values immediately, can use a Completer as follows:
  *
@@ skipping 61 matching lines @@
     // Special case where all the futures are already completed,
     // trigger the value now.
     if (futures.length == 0) {
       completer.complete(values);
     }
 
     return completer.future;
   }
 }