From e3c8c457ba8744b0f1b799c4d7d4bf24e8e61792 Mon Sep 17 00:00:00 2001
From: mo8it <mo8it@proton.me>
Date: Tue, 2 Jul 2024 01:03:55 +0200
Subject: from_str solution

---
 exercises/23_conversions/from_str.rs | 60 +++++++++++++++++++-----------------
 1 file changed, 31 insertions(+), 29 deletions(-)

(limited to 'exercises')

diff --git a/exercises/23_conversions/from_str.rs b/exercises/23_conversions/from_str.rs
index 58270f0..1b3f553 100644
--- a/exercises/23_conversions/from_str.rs
+++ b/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
-// 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 at
+// 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;
@@ -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
-// 2. Split the given string on the commas present in it
-// 3. Only 2 elements should be returned from the split, otherwise return an
-//    error
-// 4. Extract the first element from the split operation and use it as the name
-// 5. Extract the other element from the split operation and parse it into a
-//    `usize` as the age with something like `"4".parse::<usize>()`
-// 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
-
+// 1. Split the given string on the commas present in it.
+// 2. If the split operation returns less or more than 2 elements, return the
+//    error `ParsePersonError::BadLen`.
+// 3. Use the first element from the split operation as the name.
+// 4. If the name is empty, return the error `ParsePersonError::NoName`.
+// 5. Parse the second element from the split operation into a `u8` as the age.
+// 6. If parsing the age fails, return the error `ParsePersonError::ParseInt`.
 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();
-    println!("{:?}", p);
+    let p = "Mark,20".parse::<Person>();
+    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),
         );
     }
 }
-- 
cgit v1.2.3