Revert "Revert "almost there""

This reverts commit bd72dd98d6a91609bfc357f4d85689420e56d1a7.

exercises/advanced_errors/advanced_errs1.rs

@@ -7,8 +7,6 @@
 // Make this code compile! Execute `rustlings hint advanced_errs1` for
 // hints :)
 
-// I AM NOT DONE
-
 use std::num::ParseIntError;
 use std::str::FromStr;
 
@@ -24,6 +22,7 @@ impl From<CreationError> for ParsePosNonzeroError {
     fn from(e: CreationError) -> Self {
         // TODO: complete this implementation so that the `?` operator will
         // work for `CreationError`
+        ParsePosNonzeroError::Creation(e)
     }
 }
 
@@ -31,6 +30,14 @@ impl From<CreationError> for ParsePosNonzeroError {
 // `?` operator will work in the other place in the `FromStr`
 // implementation below.
 
+impl From<ParseIntError> for ParsePosNonzeroError {
+    fn from(e: ParseIntError) -> Self {
+        // TODO: complete this implementation so that the `?` operator will
+        // work for `CreationError`
+        ParsePosNonzeroError::ParseInt(e)
+    }
+}
+
 // Don't change anything below this line.
 
 impl FromStr for PositiveNonzeroInteger {

exercises/clippy/clippy1.rs

@@ -6,12 +6,10 @@
 // check clippy's suggestions from the output to solve the exercise.
 // Execute `rustlings hint clippy1` for hints :)
 
-// I AM NOT DONE
-
-use std::f32;
+use std::f32::{self, consts::PI};
 
 fn main() {
-    let pi = 3.14f32;
+    let pi = PI;
     let radius = 5.00f32;
 
     let area = pi * f32::powi(radius, 2);

exercises/clippy/clippy2.rs

@@ -1,12 +1,10 @@
 // clippy2.rs
 // Make me compile! Execute `rustlings hint clippy2` for hints :)
 
-// I AM NOT DONE
-
 fn main() {
     let mut res = 42;
     let option = Some(12);
-    for x in option {
+    if let Some(x) = option {
         res += x;
     }
     println!("{}", res);

exercises/conversions/as_ref_mut.rs

@@ -2,17 +2,15 @@
 // 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.
 
-// I AM NOT DONE
-
 // Obtain the number of bytes (not characters) in the given argument
 // Add the AsRef trait appropriately as a trait bound
-fn byte_counter<T>(arg: T) -> usize {
+fn byte_counter<T: AsRef<str>>(arg: T) -> usize {
     arg.as_ref().as_bytes().len()
 }
 
 // Obtain the number of characters (not bytes) in the given argument
 // Add the AsRef trait appropriately as a trait bound
-fn char_counter<T>(arg: T) -> usize {
+fn char_counter<T: AsRef<str>>(arg: T) -> usize {
     arg.as_ref().chars().count()
 }
 

exercises/conversions/from_into.rs

@@ -33,10 +33,30 @@ impl Default for Person {
 // 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
-
 impl From<&str> for Person {
     fn from(s: &str) -> Person {
+        if s.len() == 0 {
+            return Person::default()
+        }
+
+        let split: Vec<&str> = s.split(",").collect();
+
+        if split.len() != 2 {
+            return Person::default()
+        }
+
+        if split[0].len() == 0 {
+            return Person::default()
+        }
+
+        let age = split[1].parse::<usize>();
+
+        let mut age = match age {
+            Ok(age) => age,
+            Err(_) => return Person::default(),
+        };
+
+        Person { name: String::from(split[0]), age }
     }
 }
 

exercises/conversions/from_str.rs

@@ -26,8 +26,6 @@ enum ParsePersonError {
     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
@@ -41,6 +39,28 @@ enum ParsePersonError {
 impl FromStr for Person {
     type Err = ParsePersonError;
     fn from_str(s: &str) -> Result<Person, Self::Err> {
+        if s.len() == 0 {
+            return Err(ParsePersonError::Empty);
+        }
+
+        let split: Vec<&str> = s.split(",").collect();
+
+        if split.len() != 2 {
+            return Err(ParsePersonError::BadLen);
+        }
+
+        let name = match split[0].len() {
+            0 => return Err(ParsePersonError::NoName),
+            _ => split[0]
+        };
+        
+        let age = split[1].parse::<usize>();
+        let mut age = match age {
+            Ok(age) => age,
+            Err(err) => return Err(ParsePersonError::ParseInt(err))
+        };
+
+        Ok(Person { name: String::from(name), age })
     }
 }
 

exercises/conversions/try_from_into.rs

@@ -21,8 +21,6 @@ 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,
@@ -36,6 +34,12 @@ enum IntoColorError {
 impl TryFrom<(i16, i16, i16)> for Color {
     type Error = IntoColorError;
     fn try_from(tuple: (i16, i16, i16)) -> Result<Self, Self::Error> {
+        match tuple {
+            x if x.0 < 0 || x.0 > 255 => return Err(IntoColorError::IntConversion), 
+            x if x.1 < 0 || x.1 > 255 => return Err(IntoColorError::IntConversion),
+            x if x.2 < 0 || x.2 > 255 => return Err(IntoColorError::IntConversion),
+            x => Ok(Color {red: x.0 as u8, green: x.1 as u8, blue: x.2 as u8})
+        }
     }
 }
 
@@ -43,6 +47,12 @@ impl TryFrom<(i16, i16, i16)> for Color {
 impl TryFrom<[i16; 3]> for Color {
     type Error = IntoColorError;
     fn try_from(arr: [i16; 3]) -> Result<Self, Self::Error> {
+        match arr {
+            x if x[0] < 0 || x[0] > 255 => return Err(IntoColorError::IntConversion), 
+            x if x[1] < 0 || x[1] > 255 => return Err(IntoColorError::IntConversion),
+            x if x[2] < 0 || x[2] > 255 => return Err(IntoColorError::IntConversion),
+            x => Ok(Color {red: x[0] as u8, green: x[1] as u8, blue: x[2] as u8})
+        }
     }
 }
 
@@ -50,6 +60,13 @@ impl TryFrom<[i16; 3]> for Color {
 impl TryFrom<&[i16]> for Color {
     type Error = IntoColorError;
     fn try_from(slice: &[i16]) -> Result<Self, Self::Error> {
+        match slice {
+            x if x.len() != 3 => return Err(IntoColorError::BadLen),
+            x if x[0] < 0 || x[0] > 255 => return Err(IntoColorError::IntConversion), 
+            x if x[1] < 0 || x[1] > 255 => return Err(IntoColorError::IntConversion),
+            x if x[2] < 0 || x[2] > 255 => return Err(IntoColorError::IntConversion),
+            x => Ok(Color {red: x[0] as u8, green: x[1] as u8, blue: x[2] as u8})
+        }
     }
 }
 

exercises/conversions/using_as.rs

@@ -5,11 +5,9 @@
 // The goal is to make sure that the division does not fail to compile
 // and returns the proper type.
 
-// I AM NOT DONE
-
 fn average(values: &[f64]) -> f64 {
     let total = values.iter().sum::<f64>();
-    total / values.len()
+    total / values.len() as f64
 }
 
 fn main() {

exercises/macros/macros1.rs

@@ -1,8 +1,6 @@
 // macros1.rs
 // Make me compile! Execute `rustlings hint macros1` for hints :)
 
-// I AM NOT DONE
-
 macro_rules! my_macro {
     () => {
         println!("Check out my macro!");
@@ -10,5 +8,5 @@ macro_rules! my_macro {
 }
 
 fn main() {
-    my_macro();
+    my_macro!();
 }

exercises/macros/macros2.rs

@@ -1,14 +1,12 @@
 // macros2.rs
 // Make me compile! Execute `rustlings hint macros2` for hints :)
 
-// I AM NOT DONE
-
-fn main() {
-    my_macro!();
-}
-
 macro_rules! my_macro {
     () => {
         println!("Check out my macro!");
     };
 }
+
+fn main() {
+    my_macro!();
+}

exercises/macros/macros3.rs

@@ -2,9 +2,8 @@
 // Make me compile, without taking the macro out of the module!
 // Execute `rustlings hint macros3` for hints :)
 
-// I AM NOT DONE
-
 mod macros {
+    #[macro_export]
     macro_rules! my_macro {
         () => {
             println!("Check out my macro!");

exercises/macros/macros4.rs

@@ -1,15 +1,13 @@
 // macros4.rs
 // Make me compile! Execute `rustlings hint macros4` for hints :)
 
-// I AM NOT DONE
-
 macro_rules! my_macro {
     () => {
         println!("Check out my macro!");
-    }
+    };
     ($val:expr) => {
         println!("Look at this other macro: {}", $val);
-    }
+    };
 }
 
 fn main() {

exercises/quiz4.rs

@@ -5,7 +5,11 @@
 
 // Write a macro that passes the quiz! No hints this time, you can do it!
 
-// I AM NOT DONE
+macro_rules! my_macro {
+    ($val:expr) => {
+        format!("Hello {}", $val)
+    };
+}
 
 #[cfg(test)]
 mod tests {

exercises/standard_library_types/iterators5.rs

@@ -10,8 +10,6 @@
 //
 // Make the code compile and the tests pass.
 
-// I AM NOT DONE
-
 use std::collections::HashMap;
 
 #[derive(Clone, Copy, PartialEq, Eq)]
@@ -34,6 +32,7 @@ fn count_for(map: &HashMap<String, Progress>, value: Progress) -> usize {
 fn count_iterator(map: &HashMap<String, Progress>, value: Progress) -> usize {
     // map is a hashmap with String keys and Progress values.
     // map = { "variables1": Complete, "from_str": None, ... }
+    map.values().filter(|item| **item == value).count()
 }
 
 fn count_collection_for(collection: &[HashMap<String, Progress>], value: Progress) -> usize {
@@ -52,6 +51,11 @@ fn count_collection_iterator(collection: &[HashMap<String, Progress>], value: Pr
     // collection is a slice of hashmaps.
     // collection = [{ "variables1": Complete, "from_str": None, ... },
     //     { "variables2": Complete, ... }, ... ]
+    let result: Option<usize> = collection.iter().map(|item| count_iterator(item, value)).reduce(|accum, item| accum + item);
+    match result {
+        Some(size) => return size,
+        None => panic!()
+    }
 }
 
 #[cfg(test)]

exercises/threads/threads1.rs

@@ -6,9 +6,7 @@
 // of "waiting..." and the program ends without timing out when running,
 // you've got it :)
 
-// I AM NOT DONE
-
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 use std::thread;
 use std::time::Duration;
 
@@ -17,15 +15,17 @@ struct JobStatus {
 }
 
 fn main() {
-    let status = Arc::new(JobStatus { jobs_completed: 0 });
-    let status_shared = status.clone();
+    let status = Arc::new(Mutex::new(JobStatus { jobs_completed: 0 }));
+    let status_shared = Arc::clone(&status);
+
     thread::spawn(move || {
         for _ in 0..10 {
             thread::sleep(Duration::from_millis(250));
+            let mut status_shared = status_shared.lock().unwrap();
             status_shared.jobs_completed += 1;
         }
     });
-    while status.jobs_completed < 10 {
+    while status.lock().unwrap().jobs_completed < 10 {
         println!("waiting... ");
         thread::sleep(Duration::from_millis(500));
     }