Add methods to Result. Bump version to 2.0 and remove deprecated features.

[email protected]

Review-Url: https://codereview.chromium.org//2996143002 .

Author: lrhn

CHANGELOG.md

@@ -1,3 +1,12 @@
+## 2.0.0
+* Remove deprecated public `result.dart` and `stream_zip.dart` libraries and
+  deprecated classes `ReleaseStreamTransformer` and `CaptureStreamTransformer`.
+
+* Add `captureAll` and `flattenList` static methods to `Result`.
+
+* Change `ErrorResult` to not be generic and always be a `Result<Null>`.
+  That makes an error independent of the type of result it occurs instead of.
+
 ## 1.13.3
 
 * Make `TypeSafeStream` extend `Stream` instead of implementing it. This ensures

lib/async.dart

@@ -17,11 +17,9 @@ export "src/future_group.dart";
 export "src/lazy_stream.dart";
 export "src/null_stream_sink.dart";
 export "src/restartable_timer.dart";
-export "src/result.dart";
-export "src/result/capture_transformer.dart";
+export "src/result/result.dart";
 export "src/result/error.dart";
 export "src/result/future.dart";
-export "src/result/release_transformer.dart";
 export "src/result/value.dart";
 export "src/single_subscription_transformer.dart";
 export "src/stream_completer.dart";

lib/result.dart

@@ -4,12 +4,11 @@
 
 import 'dart:async';
 
-import '../result.dart';
+import 'result.dart';
 
-/// Use [Result.captureSinkTransformer].
-@Deprecated("Will be removed in async 2.0.0.")
+/// Used by [Result.captureSink].
 class CaptureSink<T> implements EventSink<T> {
-  final EventSink _sink;
+  final EventSink<Result<T>> _sink;
 
   CaptureSink(EventSink<Result<T>> sink) : _sink = sink;
 

lib/src/result.dart

@@ -4,22 +4,20 @@
 
 import 'dart:async';
 
-import '../result.dart';
+import 'result.dart';
 import 'capture_sink.dart';
 
 /// A stream transformer that captures a stream of events into [Result]s.
 ///
 /// The result of the transformation is a stream of [Result] values and no
-/// error events. This is the transformer used by [captureStream].
-@Deprecated("Will be removed in async 2.0.0.")
+/// error events. Exposed by [Result.captureStream].
 class CaptureStreamTransformer<T> implements StreamTransformer<T, Result<T>> {
   const CaptureStreamTransformer();
 
   Stream<Result<T>> bind(Stream<T> source) {
     return new Stream<Result<T>>.eventTransformed(source, _createSink);
   }
 
-  static EventSink _createSink(EventSink<Result> sink) {
-    return new CaptureSink(sink);
-  }
+  // Since Stream.eventTransformed is not generic, this method can be static.
+  static EventSink _createSink(EventSink<Result> sink) => new CaptureSink(sink);
 }

lib/src/result/capture_sink.dart

@@ -4,18 +4,21 @@
 
 import 'dart:async';
 
-import '../result.dart';
+import 'result.dart';
 import 'value.dart';
 
 /// A result representing a thrown error.
-class ErrorResult<T> implements Result<T> {
+class ErrorResult implements Result<Null> {
+  /// The error object that was thrown.
   final error;
+
+  /// The stack trace corresponding to where [error] was thrown.
   final StackTrace stackTrace;
 
   bool get isValue => false;
   bool get isError => true;
-  ValueResult<T> get asValue => null;
-  ErrorResult<T> get asError => this;
+  ValueResult<Null> get asValue => null;
+  ErrorResult get asError => this;
 
   ErrorResult(this.error, this.stackTrace);
 
@@ -27,7 +30,7 @@ class ErrorResult<T> implements Result<T> {
     sink.addError(error, stackTrace);
   }
 
-  Future<T> get asFuture => new Future.error(error, stackTrace);
+  Future<Null> get asFuture => new Future<Null>.error(error, stackTrace);
 
   /// Calls an error handler with the error and stacktrace.
   ///
@@ -42,4 +45,12 @@ class ErrorResult<T> implements Result<T> {
       errorHandler(error);
     }
   }
+
+  int get hashCode => error.hashCode ^ stackTrace.hashCode ^ 0x1d61823f;
+
+  /// This is equal only to an error result with equal [error] and [stackTrace].
+  bool operator ==(Object other) =>
+      other is ErrorResult &&
+      error == other.error &&
+      stackTrace == other.stackTrace;
 }

lib/src/result/capture_transformer.dart

@@ -5,7 +5,7 @@
 import 'dart:async';
 
 import '../delegate/future.dart';
-import '../result.dart';
+import 'result.dart';
 
 /// A [Future] wrapper that provides synchronous access to the result of the
 /// wrapped [Future] once it's completed.
@@ -19,15 +19,9 @@ class ResultFuture<T> extends DelegatingFuture<T> {
   Result<T> get result => _result;
   Result<T> _result;
 
-  factory ResultFuture(Future<T> future) {
-    ResultFuture<T> resultFuture;
-    resultFuture = new ResultFuture._(() async {
-      var result = await Result.capture(future);
-      resultFuture._result = result;
-      return await result.asFuture;
-    }());
-    return resultFuture;
+  ResultFuture(Future<T> future) : super(future) {
+    Result.capture(future).then((result) {
+      _result = result;
+    });
   }
-
-  ResultFuture._(Future<T> future) : super(future);
 }

lib/src/result/error.dart

@@ -4,22 +4,16 @@
 
 import 'dart:async';
 
-import '../result.dart';
+import 'result.dart';
 
-/// Use [Result.captureSinkTransformer].
-@Deprecated("Will be removed in async 2.0.0.")
+/// Used by [Result.releaseSink].
 class ReleaseSink<T> implements EventSink<Result<T>> {
   final EventSink _sink;
 
   ReleaseSink(EventSink<T> sink) : _sink = sink;
 
   void add(Result<T> result) {
-    if (result.isValue) {
-      _sink.add(result.asValue.value);
-    } else {
-      var error = result.asError;
-      _sink.addError(error.error, error.stackTrace);
-    }
+    result.addTo(_sink);
   }
 
   void addError(Object error, [StackTrace stackTrace]) {

lib/src/result/future.dart

@@ -4,19 +4,17 @@
 
 import 'dart:async';
 
-import '../result.dart';
+import 'result.dart';
 import 'release_sink.dart';
 
-/// Use [Result.releaseTransformer] instead.
-@Deprecated("Will be removed in async 2.0.0.")
+/// A transformer that releases result events as data and error events.
 class ReleaseStreamTransformer<T> implements StreamTransformer<Result<T>, T> {
   const ReleaseStreamTransformer();
 
   Stream<T> bind(Stream<Result<T>> source) {
     return new Stream<T>.eventTransformed(source, _createSink);
   }
 
-  static EventSink<Result> _createSink(EventSink sink) {
-    return new ReleaseSink(sink);
-  }
+  // Since Stream.eventTransformed is not generic, this method can be static.
+  static EventSink<Result> _createSink(EventSink sink) => new ReleaseSink(sink);
 }