Change generic comment syntax to real generic syntax.

lib/src/result.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:async';
 
 import 'result/capture_transformer.dart';
 import 'result/error.dart';
 import 'result/release_transformer.dart';
 import 'result/value.dart';
@@ skipping 58 matching lines @@
   /// Create a `Result` holding an error.
   ///
   /// Alias for [ErrorResult.ErrorResult].
   factory Result.error(Object error, [StackTrace stackTrace]) =>
       new ErrorResult(error, stackTrace);
 
   /// Capture the result of a future into a `Result` future.
   ///
   /// The resulting future will never have an error.
   /// Errors have been converted to an [ErrorResult] value.
-  static Future<Result/*<T>*/> capture/*<T>*/(Future/*<T>*/ future) {
+  static Future<Result<T>> capture<T>(Future<T> future) {
     return future.then((value) => new ValueResult(value),
         onError: (error, stackTrace) =>
-            new ErrorResult/*<T>*/(error, stackTrace));
+            new ErrorResult<T>(error, stackTrace));
   }
 
   /// Release the result of a captured future.
   ///
   /// 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/*<T>*/ release/*<T>*/(Future<Result/*<T>*/> future) =>
-      future.then/*<Future<T>>*/((result) => result.asFuture);
+  static Future<T> release<T>(Future<Result<T>> future) =>
+      future.then<Future<T>>((result) => result.asFuture);
 
   /// Capture the results of a stream into a stream of [Result] values.
   ///
   /// The returned stream will not have any error events.
   /// Errors from the source stream have been converted to [ErrorResult]s.
-  static Stream<Result/*<T>*/> captureStream/*<T>*/(Stream/*<T>*/ source) =>
-      source.transform(new CaptureStreamTransformer/*<T>*/());
+  static Stream<Result<T>> captureStream<T>(Stream<T> source) =>
+      source.transform(new CaptureStreamTransformer<T>());
 
   /// Release a stream of [result] values into a stream of the results.
   ///
   /// `Result` values of the source stream become value or error events in
   /// the returned stream as appropriate.
   /// Errors from the source stream become errors in the returned stream.
-  static Stream/*<T>*/ releaseStream/*<T>*/(Stream<Result/*<T>*/> source) =>
-      source.transform(new ReleaseStreamTransformer/*<T>*/());
+  static Stream<T> releaseStream<T>(Stream<Result<T>> source) =>
+      source.transform(new ReleaseStreamTransformer<T>());
 
   /// 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/*<T>*/ flatten/*<T>*/(Result<Result/*<T>*/> result) {
+  static Result<T> flatten<T>(Result<Result<T>> result) {
     if (result.isValue) return result.asValue.value;
-    return new ErrorResult/*<T>*/(
+    return new ErrorResult<T>(
         result.asError.error, result.asError.stackTrace);
   }
 
   /// Whether this result is a value result.
   ///
   /// Always the opposite of [isError].
   bool get isValue;
 
   /// Whether this result is an error result.
   ///
@@ skipping 14 matching lines @@
   void complete(Completer<T> completer);
 
   /// Add this result to an [EventSink].
   ///
   /// Calls the sink's `add` or `addError` method as appropriate.
   void addTo(EventSink<T> sink);
 
   /// Creates a future completed with this result as a value or an error.
   Future<T> get asFuture;
 }