summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--exercises/23_conversions/try_from_into.rs113
-rw-r--r--rustlings-macros/info.toml17
-rw-r--r--solutions/23_conversions/try_from_into.rs193
3 files changed, 246 insertions, 77 deletions
diff --git a/exercises/23_conversions/try_from_into.rs b/exercises/23_conversions/try_from_into.rs
index da45e5a..f3ae80a 100644
--- a/exercises/23_conversions/try_from_into.rs
+++ b/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));
}
}
diff --git a/rustlings-macros/info.toml b/rustlings-macros/info.toml
index 4ef1a0a..488fdac 100644
--- a/rustlings-macros/info.toml
+++ b/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?"""
diff --git a/solutions/23_conversions/try_from_into.rs b/solutions/23_conversions/try_from_into.rs
index 4e18198..acb7721 100644
--- a/solutions/23_conversions/try_from_into.rs
+++ b/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));
+ }
+}
generated by cgit v1.2.3 (git 2.46.0) at 2026-04-07 03:30:48 +0000