summaryrefslogtreecommitdiff
path: root/exercises/23_conversions
diff options
context:
space:
mode:
Diffstat (limited to 'exercises/23_conversions')
-rw-r--r--exercises/23_conversions/as_ref_mut.rs18
-rw-r--r--exercises/23_conversions/from_into.rs80
-rw-r--r--exercises/23_conversions/from_str.rs90
-rw-r--r--exercises/23_conversions/try_from_into.rs120
-rw-r--r--exercises/23_conversions/using_as.rs17
5 files changed, 133 insertions, 192 deletions
diff --git a/exercises/23_conversions/as_ref_mut.rs b/exercises/23_conversions/as_ref_mut.rs
index 2ba9e3f..54f0cd1 100644
--- a/exercises/23_conversions/as_ref_mut.rs
+++ b/exercises/23_conversions/as_ref_mut.rs
@@ -1,31 +1,27 @@
-// as_ref_mut.rs
-//
// AsRef and AsMut allow for cheap reference-to-reference conversions. Read more
// about them at https://doc.rust-lang.org/std/convert/trait.AsRef.html and
// https://doc.rust-lang.org/std/convert/trait.AsMut.html, respectively.
-//
-// Execute `rustlings hint as_ref_mut` or use the `hint` watch subcommand for a
-// hint.
-
-// I AM NOT DONE
// Obtain the number of bytes (not characters) in the given argument.
-// TODO: Add the AsRef trait appropriately as a trait bound.
+// TODO: Add the `AsRef` trait appropriately as a trait bound.
fn byte_counter<T>(arg: T) -> usize {
arg.as_ref().as_bytes().len()
}
// Obtain the number of characters (not bytes) in the given argument.
-// TODO: Add the AsRef trait appropriately as a trait bound.
+// TODO: Add the `AsRef` trait appropriately as a trait bound.
fn char_counter<T>(arg: T) -> usize {
arg.as_ref().chars().count()
}
-// Squares a number using as_mut().
+// Squares a number using `as_mut()`.
// TODO: Add the appropriate trait bound.
fn num_sq<T>(arg: &mut T) {
// TODO: Implement the function body.
- ???
+}
+
+fn main() {
+ // You can optionally experiment here.
}
#[cfg(test)]
diff --git a/exercises/23_conversions/from_into.rs b/exercises/23_conversions/from_into.rs
index 60911f3..bc2783a 100644
--- a/exercises/23_conversions/from_into.rs
+++ b/exercises/23_conversions/from_into.rs
@@ -1,89 +1,79 @@
-// from_into.rs
-//
-// The From trait is used for value-to-value conversions. If From is implemented
-// correctly for a type, the Into trait should work conversely. You can read
-// more about it at https://doc.rust-lang.org/std/convert/trait.From.html
-//
-// Execute `rustlings hint from_into` or use the `hint` watch subcommand for a
-// hint.
+// The `From` trait is used for value-to-value conversions. If `From` is
+// implemented, an implementation of `Into` is automatically provided.
+// You can read more about it in the documentation:
+// https://doc.rust-lang.org/std/convert/trait.From.html
#[derive(Debug)]
struct Person {
name: String,
- age: usize,
+ age: u8,
}
-// We implement the Default trait to use it as a fallback
-// when the provided string is not convertible into a Person object
+// We implement the Default trait to use it as a fallback when the provided
+// string is not convertible into a `Person` object.
impl Default for Person {
- fn default() -> Person {
- Person {
+ fn default() -> Self {
+ Self {
name: String::from("John"),
age: 30,
}
}
}
-// Your task is to complete this implementation in order for the line `let p =
-// Person::from("Mark,20")` to compile Please note that you'll need to parse the
-// age component into a `usize` with something like `"4".parse::<usize>()`. The
-// outcome of this needs to be handled appropriately.
+// 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, then return the default of
-// Person.
-// 2. Split the given string on the commas present in it.
-// 3. Extract the first element from the split operation and use it as the name.
-// 4. If the name is empty, then return the default of Person.
-// 5. Extract the other element from the split operation and parse it into a
-// `usize` as the age.
-// If while parsing the age, something goes wrong, then return the default of
-// Person Otherwise, then return an instantiated Person object with the results
-
-// I AM NOT DONE
-
+// 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
+// default of `Person`.
+// 3. Use the first element from the split operation as the name.
+// 4. If the name is empty, return the default of `Person`.
+// 5. Parse the second element from the split operation into a `u8` as the age.
+// 6. If parsing the age fails, return the default of `Person`.
impl From<&str> for Person {
- fn from(s: &str) -> Person {
- }
+ fn from(s: &str) -> Self {}
}
fn main() {
- // Use the `from` function
+ // Use the `from` function.
let p1 = Person::from("Mark,20");
- // Since From is implemented for Person, we should be able to use Into
+ println!("{p1:?}");
+
+ // Since `From` is implemented for Person, we are able to use `Into`.
let p2: Person = "Gerald,70".into();
- println!("{:?}", p1);
- println!("{:?}", p2);
+ println!("{p2:?}");
}
#[cfg(test)]
mod tests {
use super::*;
+
#[test]
fn test_default() {
- // Test that the default person is 30 year old John
let dp = Person::default();
assert_eq!(dp.name, "John");
assert_eq!(dp.age, 30);
}
+
#[test]
fn test_bad_convert() {
- // Test that John is returned when bad string is provided
let p = Person::from("");
assert_eq!(p.name, "John");
assert_eq!(p.age, 30);
}
+
#[test]
fn test_good_convert() {
- // Test that "Mark,20" works
let p = Person::from("Mark,20");
assert_eq!(p.name, "Mark");
assert_eq!(p.age, 20);
}
+
#[test]
fn test_bad_age() {
- // Test that "Mark,twenty" will return the default person due to an
- // error in parsing age
let p = Person::from("Mark,twenty");
assert_eq!(p.name, "John");
assert_eq!(p.age, 30);
@@ -127,14 +117,14 @@ mod tests {
#[test]
fn test_trailing_comma() {
let p: Person = Person::from("Mike,32,");
- assert_eq!(p.name, "Mike");
- assert_eq!(p.age, 32);
+ assert_eq!(p.name, "John");
+ assert_eq!(p.age, 30);
}
#[test]
fn test_trailing_comma_and_some_string() {
- let p: Person = Person::from("Mike,32,man");
- assert_eq!(p.name, "Mike");
- assert_eq!(p.age, 32);
+ let p: Person = Person::from("Mike,32,dog");
+ assert_eq!(p.name, "John");
+ assert_eq!(p.age, 30);
}
}
diff --git a/exercises/23_conversions/from_str.rs b/exercises/23_conversions/from_str.rs
index 34472c3..4b1aaa2 100644
--- a/exercises/23_conversions/from_str.rs
+++ b/exercises/23_conversions/from_str.rs
@@ -1,13 +1,9 @@
-// from_str.rs
-//
-// 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
-//
-// Execute `rustlings hint from_str` or use the `hint` watch subcommand for a
-// hint.
use std::num::ParseIntError;
use std::str::FromStr;
@@ -15,59 +11,54 @@ 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),
}
-// I AM NOT DONE
-
-// 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
+// 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>()`.
//
-// As an aside: `Box<dyn Error>` implements `From<&'_ str>`. This means that if
-// you want to return a string error message, you can do so via just using
-// return `Err("my error message".into())`.
-
+// Steps:
+// 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)]
mod tests {
use super::*;
+ use ParsePersonError::*;
#[test]
fn empty_input() {
- assert_eq!("".parse::<Person>(), Err(ParsePersonError::Empty));
+ assert_eq!("".parse::<Person>(), Err(BadLen));
}
+
#[test]
fn good_input() {
let p = "John,32".parse::<Person>();
@@ -76,58 +67,47 @@ mod tests {
assert_eq!(p.name, "John");
assert_eq!(p.age, 32);
}
+
#[test]
fn missing_age() {
- assert!(matches!(
- "John,".parse::<Person>(),
- Err(ParsePersonError::ParseInt(_))
- ));
+ assert!(matches!("John,".parse::<Person>(), Err(ParseInt(_))));
}
#[test]
fn invalid_age() {
- assert!(matches!(
- "John,twenty".parse::<Person>(),
- Err(ParsePersonError::ParseInt(_))
- ));
+ assert!(matches!("John,twenty".parse::<Person>(), Err(ParseInt(_))));
}
#[test]
fn missing_comma_and_age() {
- assert_eq!("John".parse::<Person>(), Err(ParsePersonError::BadLen));
+ assert_eq!("John".parse::<Person>(), Err(BadLen));
}
#[test]
fn missing_name() {
- assert_eq!(",1".parse::<Person>(), Err(ParsePersonError::NoName));
+ assert_eq!(",1".parse::<Person>(), Err(NoName));
}
#[test]
fn missing_name_and_age() {
- assert!(matches!(
- ",".parse::<Person>(),
- Err(ParsePersonError::NoName | ParsePersonError::ParseInt(_))
- ));
+ assert!(matches!(",".parse::<Person>(), Err(NoName | ParseInt(_))));
}
#[test]
fn missing_name_and_invalid_age() {
assert!(matches!(
",one".parse::<Person>(),
- Err(ParsePersonError::NoName | ParsePersonError::ParseInt(_))
+ Err(NoName | ParseInt(_)),
));
}
#[test]
fn trailing_comma() {
- assert_eq!("John,32,".parse::<Person>(), Err(ParsePersonError::BadLen));
+ assert_eq!("John,32,".parse::<Person>(), Err(BadLen));
}
#[test]
fn trailing_comma_and_some_string() {
- assert_eq!(
- "John,32,man".parse::<Person>(),
- Err(ParsePersonError::BadLen)
- );
+ assert_eq!("John,32,man".parse::<Person>(), Err(BadLen));
}
}
diff --git a/exercises/23_conversions/try_from_into.rs b/exercises/23_conversions/try_from_into.rs
index 32d6ef3..f3ae80a 100644
--- a/exercises/23_conversions/try_from_into.rs
+++ b/exercises/23_conversions/try_from_into.rs
@@ -1,14 +1,10 @@
-// try_from_into.rs
-//
-// 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
-//
-// Execute `rustlings hint try_from_into` or use the `hint` watch subcommand for
-// a hint.
+#![allow(clippy::useless_vec)]
use std::convert::{TryFrom, TryInto};
#[derive(Debug, PartialEq)]
@@ -18,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
@@ -27,80 +23,67 @@ enum IntoColorError {
IntConversion,
}
-// I AM NOT DONE
-
-// 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();
@@ -110,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();
@@ -142,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];
@@ -176,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/exercises/23_conversions/using_as.rs b/exercises/23_conversions/using_as.rs
index 414cef3..c131d1f 100644
--- a/exercises/23_conversions/using_as.rs
+++ b/exercises/23_conversions/using_as.rs
@@ -1,19 +1,10 @@
-// using_as.rs
-//
-// Type casting in Rust is done via the usage of the `as` operator. Please note
-// that the `as` operator is not only used when type casting. It also helps with
-// renaming imports.
-//
-// The goal is to make sure that the division does not fail to compile and
-// returns the proper type.
-//
-// Execute `rustlings hint using_as` or use the `hint` watch subcommand for a
-// hint.
-
-// I AM NOT DONE
+// Type casting in Rust is done via the usage of the `as` operator.
+// Note that the `as` operator is not only used when type casting. It also helps
+// with renaming imports.
fn average(values: &[f64]) -> f64 {
let total = values.iter().sum::<f64>();
+ // TODO: Make a conversion before dividing.
total / values.len()
}
generated by cgit v1.2.3 (git 2.46.0) at 2026-04-07 05:07:23 +0000