Additional tools for gardening.

tools/gardening_tools/base_lib/lib/src/try.dart

Index: tools/gardening_tools/base_lib/lib/src/try.dart
diff --git a/tools/gardening_tools/base_lib/lib/src/try.dart b/tools/gardening_tools/base_lib/lib/src/try.dart
new file mode 100644
index 0000000000000000000000000000000000000000..bf57c9de1b2aa8b97106716f5d28f3726bba039c
--- /dev/null
+++ b/tools/gardening_tools/base_lib/lib/src/try.dart
@@ -0,0 +1,65 @@
+import 'dart:async';
+
+/// [Try] is similar to Haskell monad, where
+/// a computation may throw an exception.
+/// There is no checking of passing null into
+/// the value, so be mindful.
+class Try<T> {
+  final T _val;
+  final StackTrace _stackTrace;
+  final Exception _err;
+
+  Try.from(this._val)
+      : _err = null,
+        _stackTrace = null;
+
+  Try.error(this._err, this._stackTrace) : _val = null;
+
+  Try<S> bind<S>(S f(T)) {
+    if (_err != null) {
+      return new Try.error(_err, _stackTrace);
+    }
+
+    try {
+      return new Try<S>.from(f(_val));
+    } catch (ex, stackTrace) {
+      return new Try<S>.error(ex, stackTrace);
+    }
+  }
+
+  Future<Try<S>> bindAsync<S>(Future<S> f(T)) async {

[Bill Hesse, 2017/08/23 15:41:25]

Future itself has an error channel and a value channel, so should an error be
sent on the error channel rather than the error of a Try on the value channel?

[mkroghj, 2017/08/25 09:28:28]

The idea for bindAsync is to change Try<Future<X>> into Future<Try<X>> and be
able to await the try of an operation. One could argue that one should use the
error channel, which basically means I would get rid of the try/catch around it.
However, if an error now occurs, it will be thrown, so any clients of bindAsync
would have to do their error handling there, and then wrap it in the Try, or
completely get rid of the try. So I think this is what one wants (if they want
to use it :))

+    if (_err != null) {
+      return new Try.error(_err, _stackTrace);
+    }
+
+    try {
+      return new Try.from(await f(_val));
+    } catch (ex, stackTrace) {
+      return new Try.error(ex, stackTrace);
+    }
+  }
+
+  void fold(caseErr(Exception), caseVal(T)) {
+    if (_err != null)

[Johnni Winther, 2017/08/23 12:40:47]

Add curly braces (dangling statements are brittle).

+      caseErr(_err);
+    else
+      caseVal(_val);
+  }
+
+  bool isError() => _err != null;

[Johnni Winther, 2017/08/23 12:40:47]

Make this a getter:

  bool get isError => _error != null;

+
+  Exception getError() => _err;

[Johnni Winther, 2017/08/23 12:40:47]

Ditto.

+  StackTrace getStackTrace() => _stackTrace;

[Johnni Winther, 2017/08/23 12:40:47]

Ditto.

+
+  T get() => _val;

[Johnni Winther, 2017/08/23 12:40:47]

Make this a getter:

  bool get value => _val;

+
+  T getOrDefault(T defval) => _err != null ? defval : _val;
+}
+
+Try<T> tryStart<T>(T action()) {
+  return new Try<int>.from(0).bind<T>((dummy) => action());
+}
+
+Future<Try<T>> tryStartAsync<T>(Future<T> action()) {
+  return new Try<int>.from(0).bindAsync<T>((dummy) => action());
+}