feat: Add back guard methods

README.md

@@ -162,25 +162,28 @@ import 'package:rust/rust.dart' as rust;
 
 typedef Result<S> = rust.Result<S, Error>
 ```
-Thus they can be used together -
+Thus inheriting all of its capabilities and the two types can be used together -
 ```dart
 import 'package:anyhow/anyhow.dart' as anyhow;
 import 'package:rust/rust.dart';
 
 void main(){
   Result<int,anyhow.Error> x = Ok(1);
-  anyhow.Result<int> y = Ok(1); // or
-  Ok(1).context(1);
+  x.context(2);
+  anyhow.Result<int> y = Ok(1);
+  y.context(2);
+  assert(x == y);
+  Cell(1); // e.g. `rust` package type
 }
 ```
 or
 ```dart
-import 'package:anyhow/anyhow.dart';
-import 'package:rust/rust.dart' hide Result;
+import 'package:anyhow/rust.dart'; // overlays anyhow on top of the `rust` package
 
 void main(){
   Result<int> x = Ok(1);
-  Ok(1).context(1);
+  x.context(1);
+  Cell(1); // e.g. `rust` package type
 }
 ```
 

lib/anyhow.dart

@@ -2,7 +2,7 @@
 library anyhow;
 
 export 'src/error.dart';
+export 'src/guard.dart';
 
-export 'package:rust/src/result/guard.dart';
 export 'package:rust/src/result/record_to_result_extensions.dart';
 export 'package:rust/src/result/result_extensions.dart';

lib/rust.dart

@@ -0,0 +1,5 @@
+library rust;
+
+export 'anyhow.dart';
+export 'package:rust/rust.dart'
+    hide Result, Ok, Err, guard, guardAsync, guardAsyncResult, guardResult, FutureResult;

lib/src/guard.dart

@@ -0,0 +1,41 @@
+import 'package:anyhow/anyhow.dart';
+
+/// Executes the function in a protected context. [func] is called inside a try catch block. If the result is not
+/// catch, then return value [func] returned inside an [Ok]. If [func] throws, then the thrown value is returned
+/// inside an [Err].
+Result<S> guard<S>(S Function() func) {
+  assert(S is! Result, "Use guardResult instead");
+  try {
+    return Ok(func());
+  } catch (e) {
+    return Err(Error(e));
+  }
+}
+
+/// Result unwrapping version of [guard]. Where [func] returns an [Result], but can still throw.
+Result<S> guardResult<S>(Result<S> Function() func) {
+  try {
+    return func();
+  } catch (e) {
+    return Err(Error(e));
+  }
+}
+
+/// Async version of [guard]
+FutureResult<S> guardAsync<S>(Future<S> Function() func) async {
+  assert(S is! Result, "Use guardAsyncResult instead");
+  try {
+    return Ok(await func());
+  } catch (e) {
+    return Err(Error(e));
+  }
+}
+
+/// Async version of [guardResult]
+FutureResult<S> guardAsyncResult<S>(Future<Result<S>> Function() func) async {
+  try {
+    return await func();
+  } catch (e) {
+    return Err(Error(e));
+  }
+}