summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--exercises/23_conversions/from_str.rs60
-rw-r--r--rustlings-macros/info.toml10
-rw-r--r--solutions/23_conversions/from_str.rs129
3 files changed, 163 insertions, 36 deletions
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),
);
}
}
diff --git a/rustlings-macros/info.toml b/rustlings-macros/info.toml
index b848e0e..4ef1a0a 100644
--- a/rustlings-macros/info.toml
+++ b/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
-of falling back to a default value.
+This is almost like the previous `from_into` exercise, but returning errors
+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::<usize>`.
+Another hint: You can use the `map_err` method of `Result` with a function or a
+closure to wrap the error from `parse::<u8>`.
Yet another hint: If you would like to propagate errors by using the `?`
operator in your solution, you might want to look at
diff --git a/solutions/23_conversions/from_str.rs b/solutions/23_conversions/from_str.rs
index 4e18198..301150b 100644
--- a/solutions/23_conversions/from_str.rs
+++ b/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),
+ );
+ }
+}
generated by cgit v1.2.3 (git 2.46.0) at 2026-04-07 08:36:18 +0000