from_str solution

exercises/23_conversions/from_str.rs

@@ -1,7 +1,8 @@
-// This is similar to from_into.rs, but this time we'll implement `FromStr` and
+// This is similar to the previous `from_into` exercise. But this time, we'll
-// return errors instead of falling back to a default value. Additionally, upon
+// implement `FromStr` and return errors instead of falling back to a default
-// implementing FromStr, you can use the `parse` method on strings to generate
+// value. Additionally, upon implementing `FromStr`, you can use the `parse`
-// an object of the implementor type. You can read more about it at
+// method on strings to generate an object of the implementor type. You can read
+// more about it in the documentation:
 // https://doc.rust-lang.org/std/str/trait.FromStr.html
 
 use std::num::ParseIntError;
@@ -10,43 +11,42 @@ use std::str::FromStr;
 #[derive(Debug, PartialEq)]
 struct Person {
     name: String,
-    age: usize,
+    age: u8,
 }
 
 // We will use this error type for the `FromStr` implementation.
 #[derive(Debug, PartialEq)]
 enum ParsePersonError {
-    // Empty input string
-    Empty,
     // Incorrect number of fields
     BadLen,
     // Empty name field
     NoName,
-    // Wrapped error from parse::<usize>()
+    // Wrapped error from parse::<u8>()
     ParseInt(ParseIntError),
 }
 
+// TODO: Complete this `From` implementation to be able to parse a `Person`
+// out of a string in the form of "Mark,20".
+// Note that you'll need to parse the age component into a `u8` with something
+// like `"4".parse::<u8>()`.
+//
 // Steps:
-// 1. If the length of the provided string is 0, an error should be returned
+// 1. Split the given string on the commas present in it.
-// 2. Split the given string on the commas present in it
+// 2. If the split operation returns less or more than 2 elements, return the
-// 3. Only 2 elements should be returned from the split, otherwise return an
+//    error `ParsePersonError::BadLen`.
-//    error
+// 3. Use the first element from the split operation as the name.
-// 4. Extract the first element from the split operation and use it as the name
+// 4. If the name is empty, return the error `ParsePersonError::NoName`.
-// 5. Extract the other element from the split operation and parse it into a
+// 5. Parse the second element from the split operation into a `u8` as the age.
-//    `usize` as the age with something like `"4".parse::<usize>()`
+// 6. If parsing the age fails, return the error `ParsePersonError::ParseInt`.
-// 6. If while extracting the name and the age something goes wrong, an error
-//    should be returned
-// If everything goes well, then return a Result of a Person object
-
 impl FromStr for Person {
     type Err = ParsePersonError;
-    fn from_str(s: &str) -> Result<Person, Self::Err> {
+
-    }
+    fn from_str(s: &str) -> Result<Self, Self::Err> {}
 }
 
 fn main() {
-    let p = "Mark,20".parse::<Person>().unwrap();
+    let p = "Mark,20".parse::<Person>();
-    println!("{:?}", p);
+    println!("{p:?}");
 }
 
 #[cfg(test)]
@@ -55,8 +55,9 @@ mod tests {
 
     #[test]
     fn empty_input() {
-        assert_eq!("".parse::<Person>(), Err(ParsePersonError::Empty));
+        assert_eq!("".parse::<Person>(), Err(ParsePersonError::BadLen));
     }
+
     #[test]
     fn good_input() {
         let p = "John,32".parse::<Person>();
@@ -65,11 +66,12 @@ mod tests {
         assert_eq!(p.name, "John");
         assert_eq!(p.age, 32);
     }
+
     #[test]
     fn missing_age() {
         assert!(matches!(
             "John,".parse::<Person>(),
-            Err(ParsePersonError::ParseInt(_))
+            Err(ParsePersonError::ParseInt(_)),
         ));
     }
 
@@ -77,7 +79,7 @@ mod tests {
     fn invalid_age() {
         assert!(matches!(
             "John,twenty".parse::<Person>(),
-            Err(ParsePersonError::ParseInt(_))
+            Err(ParsePersonError::ParseInt(_)),
         ));
     }
 
@@ -95,7 +97,7 @@ mod tests {
     fn missing_name_and_age() {
         assert!(matches!(
             ",".parse::<Person>(),
-            Err(ParsePersonError::NoName | ParsePersonError::ParseInt(_))
+            Err(ParsePersonError::NoName | ParsePersonError::ParseInt(_)),
         ));
     }
 
@@ -103,7 +105,7 @@ mod tests {
     fn missing_name_and_invalid_age() {
         assert!(matches!(
             ",one".parse::<Person>(),
-            Err(ParsePersonError::NoName | ParsePersonError::ParseInt(_))
+            Err(ParsePersonError::NoName | ParsePersonError::ParseInt(_)),
         ));
     }
 
@@ -116,7 +118,7 @@ mod tests {
     fn trailing_comma_and_some_string() {
         assert_eq!(
             "John,32,man".parse::<Person>(),
-            Err(ParsePersonError::BadLen)
+            Err(ParsePersonError::BadLen),
         );
     }
 }

rustlings-macros/info.toml

@@ -1183,13 +1183,11 @@ hint = """
 The implementation of `FromStr` should return an `Ok` with a `Person` object,
 or an `Err` with an error if the string is not valid.
 
-This is almost like the `from_into` exercise, but returning errors instead
+This is almost like the previous `from_into` exercise, but returning errors
-of falling back to a default value.
+instead of falling back to a default value.
 
-Look at the test cases to see which error variants to return.
+Another hint: You can use the `map_err` method of `Result` with a function or a
-
+closure to wrap the error from `parse::<u8>`.
-Another hint: You can use the `map_err` method of `Result` with a function
-or a closure to wrap the error from `parse::<usize>`.
 
 Yet another hint: If you would like to propagate errors by using the `?`
 operator in your solution, you might want to look at

solutions/23_conversions/from_str.rs

@@ -1 +1,128 @@
-// Solutions will be available before the stable release. Thank you for testing the beta version 🥰
+// This is similar to the previous `from_into` exercise. But this time, we'll
+// implement `FromStr` and return errors instead of falling back to a default
+// value. Additionally, upon implementing `FromStr`, you can use the `parse`
+// method on strings to generate an object of the implementor type. You can read
+// more about it in the documentation:
+// https://doc.rust-lang.org/std/str/trait.FromStr.html
+
+use std::num::ParseIntError;
+use std::str::FromStr;
+
+#[derive(Debug, PartialEq)]
+struct Person {
+    name: String,
+    age: u8,
+}
+
+// We will use this error type for the `FromStr` implementation.
+#[derive(Debug, PartialEq)]
+enum ParsePersonError {
+    // Incorrect number of fields
+    BadLen,
+    // Empty name field
+    NoName,
+    // Wrapped error from parse::<u8>()
+    ParseInt(ParseIntError),
+}
+
+impl FromStr for Person {
+    type Err = ParsePersonError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut split = s.split(',');
+        let (Some(name), Some(age), None) = (split.next(), split.next(), split.next()) else {
+            //                      ^^^^ there should be no third element
+            return Err(ParsePersonError::BadLen);
+        };
+
+        if name.is_empty() {
+            return Err(ParsePersonError::NoName);
+        }
+
+        let age = age.parse().map_err(ParsePersonError::ParseInt)?;
+
+        Ok(Self {
+            name: name.into(),
+            age,
+        })
+    }
+}
+
+fn main() {
+    let p = "Mark,20".parse::<Person>();
+    println!("{p:?}");
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn empty_input() {
+        assert_eq!("".parse::<Person>(), Err(ParsePersonError::BadLen));
+    }
+
+    #[test]
+    fn good_input() {
+        let p = "John,32".parse::<Person>();
+        assert!(p.is_ok());
+        let p = p.unwrap();
+        assert_eq!(p.name, "John");
+        assert_eq!(p.age, 32);
+    }
+
+    #[test]
+    fn missing_age() {
+        assert!(matches!(
+            "John,".parse::<Person>(),
+            Err(ParsePersonError::ParseInt(_)),
+        ));
+    }
+
+    #[test]
+    fn invalid_age() {
+        assert!(matches!(
+            "John,twenty".parse::<Person>(),
+            Err(ParsePersonError::ParseInt(_)),
+        ));
+    }
+
+    #[test]
+    fn missing_comma_and_age() {
+        assert_eq!("John".parse::<Person>(), Err(ParsePersonError::BadLen));
+    }
+
+    #[test]
+    fn missing_name() {
+        assert_eq!(",1".parse::<Person>(), Err(ParsePersonError::NoName));
+    }
+
+    #[test]
+    fn missing_name_and_age() {
+        assert!(matches!(
+            ",".parse::<Person>(),
+            Err(ParsePersonError::NoName | ParsePersonError::ParseInt(_)),
+        ));
+    }
+
+    #[test]
+    fn missing_name_and_invalid_age() {
+        assert!(matches!(
+            ",one".parse::<Person>(),
+            Err(ParsePersonError::NoName | ParsePersonError::ParseInt(_)),
+        ));
+    }
+
+    #[test]
+    fn trailing_comma() {
+        assert_eq!("John,32,".parse::<Person>(), Err(ParsePersonError::BadLen));
+    }
+
+    #[test]
+    fn trailing_comma_and_some_string() {
+        assert_eq!(
+            "John,32,man".parse::<Person>(),
+            Err(ParsePersonError::BadLen),
+        );
+    }
+}