Add Future.of that calls a function and captures the result

sdk/lib/async/future.dart

Index: sdk/lib/async/future.dart
diff --git a/sdk/lib/async/future.dart b/sdk/lib/async/future.dart
index f2d926440737fa0f0e519f45eace8a395d21bd4c..14285b516baadffb97acab02942c131cc293aaa9 100644
--- a/sdk/lib/async/future.dart
+++ b/sdk/lib/async/future.dart
@@ -85,6 +85,24 @@ part of dart.async;
 // TODO(floitsch): document chaining.
 abstract class Future<T> {
   /**
+   * Creates a future containing the result of calling [function].
+   *
+   * The result of computing [:function():] is used to return
+   * a completed future with that result.
+   * If [function] returns a [Future], this will create a future that
+   * will eventually complete with the same result.

[floitsch, 2013/02/01 12:44:11]

Maybe explain it in contrast to "immediate".
This constructor is similar to [Futureimmediate] but behaves differently, if the
result of invoking [function] returns a [Future] or throws.
If the first case the result of the factory is the result of the invocation, and
in the latter the error is caught and the returned future fails.

Or something similar.

Maybe explain the motivations when someone should use this constructor.

[Lasse Reichstein Nielsen, 2013/02/01 13:16:50]

I think I'll do it the opposite way:
 new Future.immediate(v) 
where v is not a Future, is equivalent to:
 new Future.of(() => v);

+   */
+  factory Future.of(function()) {
+    try {
+      var result = function();
+      if (result is Future) return new _FutureWrapper<T>(result);

[floitsch, 2013/02/01 12:44:11]

should we wrap?

[Lasse Reichstein Nielsen, 2013/02/01 13:16:50]

That was my question too. I decided to do it just to be safe, but I can, easily,
be convinced not to.

+      return new _FutureImpl<T>.immediate(result);
+    } catch (error, stackTrace) {
+      return new _FutureImpl<T>.immediateError(error, stackTrace);
+    }
+  }
+
+  /**
    * A future whose value is available in the next event-loop iteration.
    *
    * See [Completer]s, for futures with values that are computed asynchronously.