diff --git a/result-extended/src/lib.rs b/result-extended/src/lib.rs
index 79f0eda..b56be5f 100644
--- a/result-extended/src/lib.rs
+++ b/result-extended/src/lib.rs
@@ -35,73 +35,73 @@ pub trait FatalError: Error {}
/// Result represents a return value that might be a success, might be a fatal error, or
/// might be a normal handleable error.
-pub enum Result {
+pub enum Result {
/// The operation was successful
Ok(A),
+ /// Ordinary errors. These should be handled and the application should recover gracefully.
+ Err(E),
/// The operation encountered a fatal error. These should be bubbled up to a level that can
/// safely shut the application down.
Fatal(FE),
- /// Ordinary errors. These should be handled and the application should recover gracefully.
- Err(E),
}
-impl Result {
+impl Result {
/// Apply an infallible function to a successful value.
- pub fn map(self, mapper: O) -> Result
+ pub fn map(self, mapper: O) -> Result
where
O: FnOnce(A) -> B,
{
match self {
Result::Ok(val) => Result::Ok(mapper(val)),
- Result::Fatal(err) => Result::Fatal(err),
Result::Err(err) => Result::Err(err),
+ Result::Fatal(err) => Result::Fatal(err),
}
}
/// Apply a potentially fallible function to a successful value.
///
/// Like `Result.and_then`, the mapping function can itself fail.
- pub fn and_then(self, handler: O) -> Result
+ pub fn and_then(self, handler: O) -> Result
where
- O: FnOnce(A) -> Result,
+ O: FnOnce(A) -> Result,
{
match self {
Result::Ok(val) => handler(val),
- Result::Fatal(err) => Result::Fatal(err),
Result::Err(err) => Result::Err(err),
+ Result::Fatal(err) => Result::Fatal(err),
}
}
/// Map a normal error from one type to another. This is useful for converting an error from
/// one type to another, especially in re-throwing an underlying error. `?` syntax does not
/// work with `Result`, so you will likely need to use this a lot.
- pub fn map_err(self, mapper: O) -> Result
+ pub fn map_err(self, mapper: O) -> Result
where
O: FnOnce(E) -> F,
{
match self {
Result::Ok(val) => Result::Ok(val),
- Result::Fatal(err) => Result::Fatal(err),
Result::Err(err) => Result::Err(mapper(err)),
+ Result::Fatal(err) => Result::Fatal(err),
}
}
/// Provide a function to use to recover from (or simply re-throw) an error.
- pub fn or_else(self, handler: O) -> Result
+ pub fn or_else(self, handler: O) -> Result
where
- O: FnOnce(E) -> Result,
+ O: FnOnce(E) -> Result,
{
match self {
Result::Ok(val) => Result::Ok(val),
- Result::Fatal(err) => Result::Fatal(err),
Result::Err(err) => handler(err),
+ Result::Fatal(err) => Result::Fatal(err),
}
}
}
/// Convert from a normal `Result` type to a `Result` type. The error condition for a `Result` will
/// be treated as `Result::Err`, never `Result::Fatal`.
-impl From> for Result {
+impl From> for Result {
fn from(r: std::result::Result) -> Self {
match r {
Ok(val) => Result::Ok(val),
@@ -110,7 +110,7 @@ impl From> for Result {
}
}
-impl fmt::Debug for Result
+impl fmt::Debug for Result
where
A: fmt::Debug,
FE: fmt::Debug,
@@ -125,7 +125,7 @@ where
}
}
-impl PartialEq for Result
+impl PartialEq for Result
where
A: PartialEq,
FE: PartialEq,
@@ -142,17 +142,17 @@ where
}
/// Convenience function to create an ok value.
-pub fn ok(val: A) -> Result {
+pub fn ok(val: A) -> Result {
Result::Ok(val)
}
/// Convenience function to create an error value.
-pub fn error(err: E) -> Result {
+pub fn error(err: E) -> Result {
Result::Err(err)
}
/// Convenience function to create a fatal value.
-pub fn fatal(err: FE) -> Result {
+pub fn fatal(err: FE) -> Result {
Result::Fatal(err)
}
@@ -210,45 +210,45 @@ mod test {
#[test]
fn it_can_map_things() {
- let success: Result = ok(15);
+ let success: Result = ok(15);
assert_eq!(ok(16), success.map(|v| v + 1));
}
#[test]
fn it_can_chain_success() {
- let success: Result = ok(15);
+ let success: Result = ok(15);
assert_eq!(ok(16), success.and_then(|v| ok(v + 1)));
}
#[test]
fn it_can_handle_an_error() {
- let failure: Result = error(Error::Error);
+ let failure: Result = error(Error::Error);
assert_eq!(
- ok::(16),
+ ok::(16),
failure.or_else(|_| ok(16))
);
}
#[test]
fn early_exit_on_fatal() {
- fn ok_func() -> Result {
- let value = return_fatal!(ok::(15));
+ fn ok_func() -> Result {
+ let value = return_fatal!(ok::(15));
match value {
Ok(_) => ok(14),
Err(err) => error(err),
}
}
- fn err_func() -> Result {
- let value = return_fatal!(error::(Error::Error));
+ fn err_func() -> Result {
+ let value = return_fatal!(error::(Error::Error));
match value {
Ok(_) => panic!("shouldn't have gotten here"),
Err(_) => ok(0),
}
}
- fn fatal_func() -> Result {
- return_fatal!(fatal::(FatalError::FatalError));
+ fn fatal_func() -> Result {
+ let _ = return_fatal!(fatal::(FatalError::FatalError));
panic!("failed to bail");
}
@@ -259,19 +259,19 @@ mod test {
#[test]
fn it_can_early_exit_on_all_errors() {
- fn ok_func() -> Result {
- let value = return_error!(ok::(15));
+ fn ok_func() -> Result {
+ let value = return_error!(ok::(15));
assert_eq!(value, 15);
ok(14)
}
- fn err_func() -> Result {
- return_error!(error::(Error::Error));
+ fn err_func() -> Result {
+ return_error!(error::(Error::Error));
panic!("failed to bail");
}
- fn fatal_func() -> Result {
- return_error!(fatal::(FatalError::FatalError));
+ fn fatal_func() -> Result {
+ return_error!(fatal::(FatalError::FatalError));
panic!("failed to bail");
}