complit!!

exercises/conversions/as_ref_mut.rs

@@ -2,16 +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

@@ -18,7 +18,6 @@ impl Default for Person {
     }
 }
 
-// I AM NOT DONE
 // 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`
@@ -35,6 +34,16 @@ impl Default for Person {
 // Otherwise, then return an instantiated Person object with the results
 impl From<&str> for Person {
     fn from(s: &str) -> Person {
+        let v: Vec<&str> = s.split(',').collect();
+        if v.len() < 2 {
+            return Person::default();
+        }
+        let age = v[1].parse();
+        if v[0].is_empty() || age.is_err() {
+            Person::default()
+        } else {
+            Person{name: v[0].to_string(), age: age.unwrap()}
+        }
     }
 }
 

exercises/conversions/from_str.rs

@@ -10,7 +10,6 @@ struct Person {
     age: usize,
 }
 
-// I AM NOT DONE
 // Steps:
 // 1. If the length of the provided string is 0, then return an error
 // 2. Split the given string on the commas present in it
@@ -22,6 +21,16 @@ struct Person {
 impl FromStr for Person {
     type Err = String;
     fn from_str(s: &str) -> Result<Person, Self::Err> {
+        let v: Vec<&str> = s.split(",").collect();
+        if v.len() < 2 {
+            return Err("need to args".to_string());
+        }
+        let age = v[1].parse();
+        if v[0].is_empty() || age.is_err() {
+            Err("wrong".to_string())
+        } else {
+            Ok(Person{name: v[0].to_string(), age: age.unwrap()})
+        }
     }
 }
 
@@ -82,4 +91,4 @@ mod tests {
         ",one".parse::<Person>().unwrap();
     }
 
-}
+}

exercises/conversions/try_from_into.rs

@@ -10,7 +10,6 @@ struct Person {
     age: usize,
 }
 
-// I AM NOT DONE
 // Your task is to complete this implementation
 // in order for the line `let p = Person::try_from("Mark,20")` to compile
 // and return an Ok result of inner type Person.
@@ -29,6 +28,16 @@ struct Person {
 impl TryFrom<&str> for Person {
     type Error = String;
     fn try_from(s: &str) -> Result<Self, Self::Error> {
+        let v: Vec<&str> = s.split(",").collect();
+        if v.len() < 2 {
+            return Err("need to args".to_string());
+        }
+        let age = v[1].parse();
+        if v[0].is_empty() || age.is_err() {
+            Err("wrong".to_string())
+        } else {
+            Ok(Person{name: v[0].to_string(), age: age.unwrap()})
+        }
     }
 }
 
@@ -99,4 +108,4 @@ mod tests {
     fn test_missing_name_and_invalid_age() {
         let _: Person = ",one".try_into().unwrap();
     }
-}
+}

exercises/conversions/using_as.rs

@@ -2,16 +2,15 @@
 // Please note that the `as` operator is not only used when type casting.
 // It also helps with renaming imports.
 
-// I AM NOT DONE
 // The goal is to make sure that the division does not fail to compile
 fn average(values: &[f64]) -> f64 {
     let total = values
         .iter()
         .fold(0.0, |a, b| a + b);
-    total / values.len()
+    total / values.len() as f64
 }
 
 fn main() {
     let values = [3.5, 0.3, 13.0, 11.7];
     println!("{}", average(&values));
-}
+}

exercises/threads/threads1.rs

@@ -5,9 +5,8 @@
 // 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::Mutex;
 use std::thread;
 use std::time::Duration;
 
@@ -16,15 +15,15 @@ struct JobStatus {
 }
 
 fn main() {
-    let status = Arc::new(JobStatus { jobs_completed: 0 });
+    let status = Arc::new(Mutex::new(JobStatus { jobs_completed: 0 }));
     let status_shared = status.clone();
     thread::spawn(move || {
         for _ in 0..10 {
             thread::sleep(Duration::from_millis(250));
-            status_shared.jobs_completed += 1;
+            status_shared.lock().unwrap().jobs_completed += 1;
         }
     });
-    while status.jobs_completed < 10 {
+    while status.lock().unwrap().jobs_completed < 10 {
         println!("waiting... ");
         thread::sleep(Duration::from_millis(500));
     }