Add Result.flatten.

pkg/async/lib/result.dart

 // Copyright (c) 2013, 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.
 
 /**
  * Capture asynchronous results into synchronous values, and release them again.
  *
  * Capturing a result (either a returned value or a thrown error)
  * means converting it into a [Result] -
  * either a [ValueResult] or an [ErrorResult].
  *
  * This value can release itself by writing itself either to a
  * [EventSink] or a [Completer], or by becoming a [Future].
  */
 library dart.pkg.async.results;
 
 import "dart:async";
 
 /**
  * The result of a computation.
  */
 abstract class Result<T> {
   /**
    * Create a `Result` with the result of calling [computation].
    *
    * This generates either a [ValueResult] with the value returned by
    * calling `computation`, or an [ErrorResult] with an error thrown by
    * the call.
    */
-  Result(T computation()) {
+  factory Result(T computation()) {
     try {
       return new ValueResult(computation());
     } catch (e, s) {
       return new ErrorResult(e, s);
     }
   }
 
   /**
    * Create a `Result` holding a value.
    *
@@ skipping 23 matching lines @@
    * The resulting future will never have an error.
    * Errors have been converted to an [ErrorResult] value.
    */
   static Future<Result> capture(Future future) {
     return future.then(_captureValue, onError: _captureError);
   }
 
   /**
    * Release the result of a captured future.
    *
-   * Converts the [Result] value of the given [future] to a result or error
+   * Converts the [Result] value of the given [future] to a value or error
    * completion of the returned future.
    *
    * If [future] completes with an error, the returned future completes with
    * the same error.
    */
   static Future release(Future<Result> future) {
     return future.then(_release);
   }
 
   /**
@@ skipping 15 matching lines @@
    * the retuned stream as appropriate.
    * Errors from the source stream become errors in the returned stream.
    *
    * Shorthand for transforming the stream using [ReleaseStreamTransformer].
    */
   static Stream releaseStream(Stream<Result> source) {
     return source.transform(const ReleaseStreamTransformer());
   }
 
   /**
+   * Converts a result of a result to a single result.
+   *
+   * If the result is an error, or it is a `Result` value
+   * which is then an error, then a result with that error is returned.
+   * Otherwise both levels of results are value results, and a single
+   * result with the value is returned.
+   */
+  static Result flatten(Result<Result> result) {
+    if (result.isError) return result;
+    return result.asValue.value;
+  }
+
+  /**
    * Whether this result is a value result.
    *
    * Always the opposite of [isError].
    */
   bool get isValue;
 
   /**
    * Whether this result is an error result.
    *
    * Always the opposite of [isValue].
@@ skipping 149 matching lines @@
     }
   }
   void addError(Object error, StackTrace stackTrace) {
     // Errors may be added by intermediate processing, even if it is never
     // added by CaptureSink.
     _sink.addError(error, stackTrace);
   }
 
   void close() { _sink.close(); }
 }