Implemented error conversion for FromResidual<Fallible<U>> to Fallible<E> where E: From<U>

Author: MathiasPius

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fallible-option"
-version = "0.1.0"
+version = "0.1.1"
 authors = ["Mathias Pius <contact@pius.io>"]
 description = "Fallible is an Option with inverted Try-semantics."
 keywords = ["error-handling", "result", "try", "fallible"]

src/lib.rs

@@ -633,10 +633,16 @@ impl<E> Try for Fallible<E> {
     }
 }
 
-impl<E> FromResidual<Fallible<E>> for Fallible<E> {
+impl<E, U> FromResidual<Fallible<U>> for Fallible<E>
+where
+    E: From<U>,
+{
     #[inline]
-    fn from_residual(residual: Fallible<E>) -> Self {
-        residual
+    fn from_residual(residual: Fallible<U>) -> Self {
+        match residual {
+            Success => Success,
+            Fail(u) => Fail(u.into()),
+        }
     }
 }
 
@@ -669,3 +675,40 @@ impl<E> FromResidual<Result<Infallible, E>> for Fallible<E> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::Fallible::{self, Fail, Success};
+
+    #[test]
+    fn casting_conversion() {
+        #[derive(Debug, PartialEq)]
+        struct InnerError(pub u8);
+
+        #[derive(Debug, PartialEq)]
+        enum OuterError {
+            Inner(InnerError),
+        }
+
+        impl From<InnerError> for OuterError {
+            fn from(value: InnerError) -> Self {
+                OuterError::Inner(value)
+            }
+        }
+
+        fn inner_error() -> Fallible<InnerError> {
+            Fail(InnerError(1))
+        }
+
+        fn outer_error() -> Fallible<OuterError> {
+            inner_error()?;
+
+            Success
+        }
+
+        assert_eq!(
+            outer_error().unwrap_fail(),
+            OuterError::Inner(InnerError(1))
+        );
+    }
+}