Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(534)

Unified Diff: lib/src/result.dart

Issue 1777453002: Modernize the package's style. (Closed) Base URL: git@github.com:dart-lang/async.git@master
Patch Set: Created 4 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: lib/src/result.dart
diff --git a/lib/src/result.dart b/lib/src/result.dart
new file mode 100644
index 0000000000000000000000000000000000000000..f5f196cd165a9893f1cf539aeefbd7fd43024b4e
--- /dev/null
+++ b/lib/src/result.dart
@@ -0,0 +1,163 @@
+// 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';
+import 'stream_sink_transformer.dart';
+
+/// The result of a computation.
+///
+/// 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].
+abstract class Result<T> {
+ /// 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.
Lasse Reichstein Nielsen 2016/03/08 10:40:37 You can refer to `captureStream` here. This is the
nweiz 2016/03/08 20:23:40 Done.
+ static const StreamTransformer<Object, Result> captureStreamTransformer =
+ const CaptureStreamTransformer();
+
+ /// A stream transformer that releases a stream of result events.
+ ///
+ /// The result of the transformation is a stream of values and error events.
+ static const StreamTransformer<Object, Result> releaseStreamTransformer =
+ const ReleaseStreamTransformer();
+
+ /// A sink transformer that captures events into [Result]s.
+ ///
+ /// The result of the transformation is a sink that only forwards [Result]
+ /// values and no error events.
+ static const StreamSinkTransformer<Object, Result> captureSinkTransformer =
+ const StreamSinkTransformer.fromStreamTransformer(
+ const CaptureStreamTransformer());
+
+ /// A sink transformer that releases result events.
+ ///
+ /// The result of the transformation is a sink that forwards of values and
+ /// error events.
+ static const StreamSinkTransformer<Object, Result> releaseSinkTransformer =
+ const StreamSinkTransformer.fromStreamTransformer(
+ const ReleaseStreamTransformer());
+
+ /// 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.
+ factory Result(T computation()) {
+ try {
+ return new ValueResult(computation());
+ } catch (e, s) {
+ return new ErrorResult(e, s);
+ }
+ }
+
+ /// Create a `Result` holding a value.
+ ///
+ /// Alias for [ValueResult.ValueResult].
+ factory Result.value(T value) = ValueResult<T>;
+
+ /// Create a `Result` holding an error.
+ ///
+ /// Alias for [ErrorResult.ErrorResult].
+ factory Result.error(Object error, [StackTrace stackTrace]) =>
+ new ErrorResult(error, stackTrace);
+
+ // Helper functions.
+ static _captureValue(value) => new ValueResult(value);
Lasse Reichstein Nielsen 2016/03/08 10:40:37 Can we use `ValueResult#` instead of `_captureValu
nweiz 2016/03/08 20:23:40 I believe it's not implemented anywhere but the VM
+ static _captureError(error, stack) => new ErrorResult(error, stack);
+ static _release(Result v) {
+ if (v.isValue) return v.asValue.value; // Avoid wrapping in future.
+ return v.asFuture;
+ }
+
+ /// 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> 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 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);
+ }
+
+ /// 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.
+ ///
+ /// Shorthand for transforming the stream using [CaptureStreamTransformer].
+ static Stream<Result> captureStream(Stream source) {
+ return source.transform(const CaptureStreamTransformer());
+ }
+
+ /// 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.
+ ///
+ /// 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].
+ bool get isError;
+
+ /// If this is a value result, return itself.
+ ///
+ /// Otherwise return `null`.
+ ValueResult<T> get asValue;
+
+ /// If this is an error result, return itself.
+ ///
+ /// Otherwise return `null`.
+ ErrorResult get asError;
+
+ /// Complete a completer with this result.
+ 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;
+}

Powered by Google App Engine
This is Rietveld 408576698