update fatality impl

node/fatality/Cargo.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 authors = ["Parity Technologies <[email protected]>"]
 edition = "2021"
 description = "Fatality extension to crate thiserror"
+readme = "README.md"
 
 [dependencies]
 fatality-proc-macro = { path = "./proc-macro" }
@@ -12,3 +13,4 @@ thiserror = "1.0"
 [dev-dependencies]
 trybuild = "1.0"
 thiserror = "1.0"
+log = "0.4"

node/fatality/README.md

@@ -10,7 +10,7 @@ and any unknown annotations will be passed to that.
 
 `#[fatality]` currently provides a `trait Fatality` with a single `fn is_fatal(&self) -> bool` by default.
 
-Annotating with `#[fatality(splitabl)]` (which disallows usage of `forward` variant annotations), allows to split the type into two sub-types, a `Jfyi*` and a `Fatal*` one via `fn split(self) -> Result<Self::Jfyi, Self::Fatal>`.
+Annotating with `#[fatality(splitable)]` (which disallows usage of `forward` variant annotations), allows to split the type into two sub-types, a `Jfyi*` and a `Fatal*` one via `fn split(self) -> Result<Self::Jfyi, Self::Fatal>`.
 
 
 The derive macro implements them, and can defer calls, based on `thiserror` annotations, specifically
@@ -56,19 +56,20 @@ enum Yikes {
     Dead,
 }
 
-fn foo() -> Result<(), Yikes> {
+fn foo() -> Result<[u8;32], Yikes> {
     Err(Yikes::Dead)
 }
 
 fn i_call_foo() -> Result<(), FatalYikes> {
-    // TODO: not yet implemented
-    let x = foo().fatal_or_log(|jfyi| { log::warn!(..) })?;
+    // availble via a convenience trait `Nested` that is implemented
+    // for any `Result` whose error type implements `Split`.
+    let x: Result<[u8;32], Jfyi> = foo().into_nested()?;
 }
 
 fn i_call_foo_too() -> Result<(), FatalYikes> {
-    // implemented
-    if let Err(e) = foo() {
-        log::warn!("Jfyi: {:?}", e.split()?);
+    if let Err(jfyi_and_fatal_ones) = foo() {
+        // bail if bad, otherwise just log it
+        log::warn!("Jfyi: {:?}", jfyi_and_fatal_ones.split()?);
     }
 }
 ```

node/fatality/proc-macro/src/lib.rs

@@ -574,6 +574,8 @@ fn fatality_gen(attr: Attr, item: ItemEnum) -> Result<TokenStream, syn::Error> {
 	Ok(ts)
 }
 
+/// The declaration of `#[fatality(splitable)]` or `#[fatality]`
+/// outside the `enum YourError`.
 #[derive(Clone, Copy)]
 enum Attr {
 	Splitable(kw::splitable),

node/fatality/src/lib.rs

@@ -19,10 +19,13 @@ pub use thiserror;
 
 /// Determine the fatality of an error.
 pub trait Fatality: std::error::Error + std::fmt::Debug {
+	/// Returns `true` if the error variant is _fatal_
+	/// or `false` if it is more of a informational error.
 	fn is_fatal(&self) -> bool;
 }
 
-/// Spl
+/// Allows to split an error into two types - a fatal
+/// and a informational enum error type, that can be further consumed.
 pub trait Split: std::error::Error + std::fmt::Debug {
 	type Jfyi: ::std::error::Error + Send + Sync + 'static;
 	type Fatal: ::std::error::Error + Send + Sync + 'static;
@@ -38,6 +41,25 @@ pub trait Split: std::error::Error + std::fmt::Debug {
 	fn split(&self) -> Result<Self::Jfyi, Self::Fatal>;
 }
 
+/// Converts a flat, yet `splitable` error into a nested `Result<Result<_,Jfyi>, Fatal>`
+/// error type.
+pub trait Nested<T, E: Split> {
+	/// Convert into a nested error rather than a flat one, commonly for direct handling.
+	fn into_nested(self) -> Result<Result<T, <E as Split>::Jfyi>, <E as Split>::Fatal> {
+		match self {
+			Ok(t) => Ok(t),
+			Err(e) => match e.split() {
+				Ok(jfyi) => Ok(Err(jfyi)),
+				Err(fatal) => Err(fatal),
+			},
+		}
+	}
+}
+
+impl<T, E: Split> Nested<T, E> for std::result::Result<T, E> {
+	// uses the default impl
+}
+
 #[cfg(test)]
 mod tests {
 	use super::*;