From b756e8ca81f9941c107dd9674309ab66763fa5fa Mon Sep 17 00:00:00 2001 From: Savanni D'Gerinel Date: Wed, 18 Oct 2023 22:13:11 -0400 Subject: [PATCH] Reverse the order of Error and FatalError parameters in the Result In other usage, I discovered that it's rather confusing to have the parameters in the order that they were in. It feels better to have the fatal error after the regular error. --- result-extended/src/lib.rs | 72 +++++++++++++++++++------------------- 1 file changed, 36 insertions(+), 36 deletions(-) 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"); }