try_from_into solution

exercises/23_conversions/try_from_into.rs

@@ -1,9 +1,10 @@
-// TryFrom is a simple and safe type conversion that may fail in a controlled
-// way under some circumstances. Basically, this is the same as From. The main
-// difference is that this should return a Result type instead of the target
-// type itself. You can read more about it at
+// `TryFrom` is a simple and safe type conversion that may fail in a controlled
+// way under some circumstances. Basically, this is the same as `From`. The main
+// difference is that this should return a `Result` type instead of the target
+// type itself. You can read more about it in the documentation:
 // https://doc.rust-lang.org/std/convert/trait.TryFrom.html
 
+#![allow(clippy::useless_vec)]
 use std::convert::{TryFrom, TryInto};
 
 #[derive(Debug, PartialEq)]
@@ -13,7 +14,7 @@ struct Color {
     blue: u8,
 }
 
-// We will use this error type for these `TryFrom` conversions.
+// We will use this error type for the `TryFrom` conversions.
 #[derive(Debug, PartialEq)]
 enum IntoColorError {
     // Incorrect length of slice
@@ -22,78 +23,67 @@ enum IntoColorError {
     IntConversion,
 }
 
-// Your task is to complete this implementation and return an Ok result of inner
-// type Color. You need to create an implementation for a tuple of three
-// integers, an array of three integers, and a slice of integers.
-//
-// Note that the implementation for tuple and array will be checked at compile
-// time, but the slice implementation needs to check the slice length! Also note
-// that correct RGB color values must be integers in the 0..=255 range.
-
-// Tuple implementation
+// TODO: Tuple implementation.
+// Correct RGB color values must be integers in the 0..=255 range.
 impl TryFrom<(i16, i16, i16)> for Color {
     type Error = IntoColorError;
-    fn try_from(tuple: (i16, i16, i16)) -> Result<Self, Self::Error> {
-    }
+
+    fn try_from(tuple: (i16, i16, i16)) -> Result<Self, Self::Error> {}
 }
 
-// Array implementation
+// TODO: Array implementation.
 impl TryFrom<[i16; 3]> for Color {
     type Error = IntoColorError;
-    fn try_from(arr: [i16; 3]) -> Result<Self, Self::Error> {
-    }
+
+    fn try_from(arr: [i16; 3]) -> Result<Self, Self::Error> {}
 }
 
-// Slice implementation
+// TODO: Slice implementation.
+// This implementation needs to check the slice length.
 impl TryFrom<&[i16]> for Color {
     type Error = IntoColorError;
-    fn try_from(slice: &[i16]) -> Result<Self, Self::Error> {
-    }
+
+    fn try_from(slice: &[i16]) -> Result<Self, Self::Error> {}
 }
 
 fn main() {
-    // Use the `try_from` function
+    // Using the `try_from` function.
     let c1 = Color::try_from((183, 65, 14));
-    println!("{:?}", c1);
+    println!("{c1:?}");
 
-    // Since TryFrom is implemented for Color, we should be able to use TryInto
+    // Since `TryFrom` is implemented for `Color`, we can use `TryInto`.
     let c2: Result<Color, _> = [183, 65, 14].try_into();
-    println!("{:?}", c2);
+    println!("{c2:?}");
 
     let v = vec![183, 65, 14];
-    // With slice we should use `try_from` function
+    // With slice we should use the `try_from` function
     let c3 = Color::try_from(&v[..]);
-    println!("{:?}", c3);
-    // or take slice within round brackets and use TryInto
+    println!("{c3:?}");
+    // or put the slice within round brackets and use `try_into`.
     let c4: Result<Color, _> = (&v[..]).try_into();
-    println!("{:?}", c4);
+    println!("{c4:?}");
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use IntoColorError::*;
 
     #[test]
     fn test_tuple_out_of_range_positive() {
-        assert_eq!(
-            Color::try_from((256, 1000, 10000)),
-            Err(IntoColorError::IntConversion)
-        );
+        assert_eq!(Color::try_from((256, 1000, 10000)), Err(IntConversion));
     }
+
     #[test]
     fn test_tuple_out_of_range_negative() {
-        assert_eq!(
-            Color::try_from((-1, -10, -256)),
-            Err(IntoColorError::IntConversion)
-        );
+        assert_eq!(Color::try_from((-1, -10, -256)), Err(IntConversion));
     }
+
     #[test]
     fn test_tuple_sum() {
-        assert_eq!(
-            Color::try_from((-1, 255, 255)),
-            Err(IntoColorError::IntConversion)
-        );
+        assert_eq!(Color::try_from((-1, 255, 255)), Err(IntConversion));
     }
+
     #[test]
     fn test_tuple_correct() {
         let c: Result<Color, _> = (183, 65, 14).try_into();
@@ -103,25 +93,29 @@ mod tests {
             Color {
                 red: 183,
                 green: 65,
-                blue: 14
+                blue: 14,
             }
         );
     }
+
     #[test]
     fn test_array_out_of_range_positive() {
         let c: Result<Color, _> = [1000, 10000, 256].try_into();
-        assert_eq!(c, Err(IntoColorError::IntConversion));
+        assert_eq!(c, Err(IntConversion));
     }
+
     #[test]
     fn test_array_out_of_range_negative() {
         let c: Result<Color, _> = [-10, -256, -1].try_into();
-        assert_eq!(c, Err(IntoColorError::IntConversion));
+        assert_eq!(c, Err(IntConversion));
     }
+
     #[test]
     fn test_array_sum() {
         let c: Result<Color, _> = [-1, 255, 255].try_into();
-        assert_eq!(c, Err(IntoColorError::IntConversion));
+        assert_eq!(c, Err(IntConversion));
     }
+
     #[test]
     fn test_array_correct() {
         let c: Result<Color, _> = [183, 65, 14].try_into();
@@ -135,30 +129,25 @@ mod tests {
             }
         );
     }
+
     #[test]
     fn test_slice_out_of_range_positive() {
         let arr = [10000, 256, 1000];
-        assert_eq!(
-            Color::try_from(&arr[..]),
-            Err(IntoColorError::IntConversion)
-        );
+        assert_eq!(Color::try_from(&arr[..]), Err(IntConversion));
     }
+
     #[test]
     fn test_slice_out_of_range_negative() {
         let arr = [-256, -1, -10];
-        assert_eq!(
-            Color::try_from(&arr[..]),
-            Err(IntoColorError::IntConversion)
-        );
+        assert_eq!(Color::try_from(&arr[..]), Err(IntConversion));
     }
+
     #[test]
     fn test_slice_sum() {
         let arr = [-1, 255, 255];
-        assert_eq!(
-            Color::try_from(&arr[..]),
-            Err(IntoColorError::IntConversion)
-        );
+        assert_eq!(Color::try_from(&arr[..]), Err(IntConversion));
     }
+
     #[test]
     fn test_slice_correct() {
         let v = vec![183, 65, 14];
@@ -169,18 +158,20 @@ mod tests {
             Color {
                 red: 183,
                 green: 65,
-                blue: 14
+                blue: 14,
             }
         );
     }
+
     #[test]
     fn test_slice_excess_length() {
         let v = vec![0, 0, 0, 0];
-        assert_eq!(Color::try_from(&v[..]), Err(IntoColorError::BadLen));
+        assert_eq!(Color::try_from(&v[..]), Err(BadLen));
     }
+
     #[test]
     fn test_slice_insufficient_length() {
         let v = vec![0, 0];
-        assert_eq!(Color::try_from(&v[..]), Err(IntoColorError::BadLen));
+        assert_eq!(Color::try_from(&v[..]), Err(BadLen));
     }
 }

rustlings-macros/info.toml

@@ -1197,21 +1197,8 @@ https://doc.rust-lang.org/stable/rust-by-example/error/multiple_error_types/reen
 name = "try_from_into"
 dir = "23_conversions"
 hint = """
-Follow the steps provided right before the `TryFrom` implementation.
-You can also use the example at
-https://doc.rust-lang.org/std/convert/trait.TryFrom.html
-
-Is there an implementation of `TryFrom` in the standard library that
-can both do the required integer conversion and check the range of the input?
-
-Another hint: Look at the test cases to see which error variants to return.
-
-Yet another hint: You can use the `map_err` or `or` methods of `Result` to
-convert errors.
-
-Yet another hint: If you would like to propagate errors by using the `?`
-operator in your solution, you might want to look at
-https://doc.rust-lang.org/stable/rust-by-example/error/multiple_error_types/reenter_question_mark.html
+Is there an implementation of `TryFrom` in the standard library that can both do
+the required integer conversion and check the range of the input?
 
 Challenge: Can you make the `TryFrom` implementations generic over many integer types?"""
 

solutions/23_conversions/try_from_into.rs

@@ -1 +1,192 @@
-// Solutions will be available before the stable release. Thank you for testing the beta version 🥰
+// `TryFrom` is a simple and safe type conversion that may fail in a controlled
+// way under some circumstances. Basically, this is the same as `From`. The main
+// difference is that this should return a `Result` type instead of the target
+// type itself. You can read more about it in the documentation:
+// https://doc.rust-lang.org/std/convert/trait.TryFrom.html
+
+use std::convert::{TryFrom, TryInto};
+
+#[derive(Debug, PartialEq)]
+struct Color {
+    red: u8,
+    green: u8,
+    blue: u8,
+}
+
+// We will use this error type for the `TryFrom` conversions.
+#[derive(Debug, PartialEq)]
+enum IntoColorError {
+    // Incorrect length of slice
+    BadLen,
+    // Integer conversion error
+    IntConversion,
+}
+
+impl TryFrom<(i16, i16, i16)> for Color {
+    type Error = IntoColorError;
+
+    fn try_from(tuple: (i16, i16, i16)) -> Result<Self, Self::Error> {
+        let (Ok(red), Ok(green), Ok(blue)) = (
+            u8::try_from(tuple.0),
+            u8::try_from(tuple.1),
+            u8::try_from(tuple.2),
+        ) else {
+            return Err(IntoColorError::IntConversion);
+        };
+
+        Ok(Self { red, green, blue })
+    }
+}
+
+impl TryFrom<[i16; 3]> for Color {
+    type Error = IntoColorError;
+
+    fn try_from(arr: [i16; 3]) -> Result<Self, Self::Error> {
+        // Reuse the implementation for a tuple.
+        Self::try_from((arr[0], arr[1], arr[2]))
+    }
+}
+
+impl TryFrom<&[i16]> for Color {
+    type Error = IntoColorError;
+
+    fn try_from(slice: &[i16]) -> Result<Self, Self::Error> {
+        // Check the length.
+        if slice.len() != 3 {
+            return Err(IntoColorError::BadLen);
+        }
+
+        // Reuse the implementation for a tuple.
+        Self::try_from((slice[0], slice[1], slice[2]))
+    }
+}
+
+fn main() {
+    // Using the `try_from` function.
+    let c1 = Color::try_from((183, 65, 14));
+    println!("{c1:?}");
+
+    // Since `TryFrom` is implemented for `Color`, we can use `TryInto`.
+    let c2: Result<Color, _> = [183, 65, 14].try_into();
+    println!("{c2:?}");
+
+    let v = vec![183, 65, 14];
+    // With slice we should use the `try_from` function
+    let c3 = Color::try_from(&v[..]);
+    println!("{c3:?}");
+    // or put the slice within round brackets and use `try_into`.
+    let c4: Result<Color, _> = (&v[..]).try_into();
+    println!("{c4:?}");
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use IntoColorError::*;
+
+    #[test]
+    fn test_tuple_out_of_range_positive() {
+        assert_eq!(Color::try_from((256, 1000, 10000)), Err(IntConversion));
+    }
+
+    #[test]
+    fn test_tuple_out_of_range_negative() {
+        assert_eq!(Color::try_from((-1, -10, -256)), Err(IntConversion));
+    }
+
+    #[test]
+    fn test_tuple_sum() {
+        assert_eq!(Color::try_from((-1, 255, 255)), Err(IntConversion));
+    }
+
+    #[test]
+    fn test_tuple_correct() {
+        let c: Result<Color, _> = (183, 65, 14).try_into();
+        assert!(c.is_ok());
+        assert_eq!(
+            c.unwrap(),
+            Color {
+                red: 183,
+                green: 65,
+                blue: 14,
+            }
+        );
+    }
+
+    #[test]
+    fn test_array_out_of_range_positive() {
+        let c: Result<Color, _> = [1000, 10000, 256].try_into();
+        assert_eq!(c, Err(IntConversion));
+    }
+
+    #[test]
+    fn test_array_out_of_range_negative() {
+        let c: Result<Color, _> = [-10, -256, -1].try_into();
+        assert_eq!(c, Err(IntConversion));
+    }
+
+    #[test]
+    fn test_array_sum() {
+        let c: Result<Color, _> = [-1, 255, 255].try_into();
+        assert_eq!(c, Err(IntConversion));
+    }
+
+    #[test]
+    fn test_array_correct() {
+        let c: Result<Color, _> = [183, 65, 14].try_into();
+        assert!(c.is_ok());
+        assert_eq!(
+            c.unwrap(),
+            Color {
+                red: 183,
+                green: 65,
+                blue: 14
+            }
+        );
+    }
+
+    #[test]
+    fn test_slice_out_of_range_positive() {
+        let arr = [10000, 256, 1000];
+        assert_eq!(Color::try_from(&arr[..]), Err(IntConversion));
+    }
+
+    #[test]
+    fn test_slice_out_of_range_negative() {
+        let arr = [-256, -1, -10];
+        assert_eq!(Color::try_from(&arr[..]), Err(IntConversion));
+    }
+
+    #[test]
+    fn test_slice_sum() {
+        let arr = [-1, 255, 255];
+        assert_eq!(Color::try_from(&arr[..]), Err(IntConversion));
+    }
+
+    #[test]
+    fn test_slice_correct() {
+        let v = vec![183, 65, 14];
+        let c: Result<Color, _> = Color::try_from(&v[..]);
+        assert!(c.is_ok());
+        assert_eq!(
+            c.unwrap(),
+            Color {
+                red: 183,
+                green: 65,
+                blue: 14,
+            }
+        );
+    }
+
+    #[test]
+    fn test_slice_excess_length() {
+        let v = vec![0, 0, 0, 0];
+        assert_eq!(Color::try_from(&v[..]), Err(BadLen));
+    }
+
+    #[test]
+    fn test_slice_insufficient_length() {
+        let v = vec![0, 0];
+        assert_eq!(Color::try_from(&v[..]), Err(BadLen));
+    }
+}