Merge branch 'part03' into part04

codes/rust_lang/part02/src/main.rs

@@ -51,7 +51,7 @@ fn find_min(tab: [i32; SIZE]) -> ([i32; SIZE], NumberOrNothing) {
     let mut min = NumberOrNothing::Nothing;
     for t in tab {
         match min {
-            NumberOrNothing::Nothing => min = NumberOrNothing::Number(t),
+            NumberOrNothing::Nothing => min = NumberOrNothing::new(t),
             NumberOrNothing::Number(val) => min = NumberOrNothing::new(min_i32(val, t)),
         }
     }

codes/rust_lang/part03/src/main.rs

-/// Rust basics:
-///     - Enum types (algebraic data types)
-///     - Pattern matching
-///     - Panic is now useless
-///     - Static function
+/// In part03 we introduce genericity through traits and in particular, [Copy],
+/// [Clone], [std::fmt::Display] .
 
 enum SomethingOrNothing<T> {
     Nothing,
@@ -20,12 +17,42 @@ impl<T: std::fmt::Display> SomethingOrNothing<T> {
     }
 }
 
+impl<T: Clone> Clone for SomethingOrNothing<T> {
+    fn clone(&self) -> Self {
+        match self {
+            SomethingOrNothing::Nothing => SomethingOrNothing::Nothing,
+            SomethingOrNothing::Something(val) => SomethingOrNothing::Something(val.clone()),
+        }
+    }
+}
+
+impl<T: Copy> Copy for SomethingOrNothing<T> {}
+
 // If we remove Copy, we have a problem with the t in tab
 // in the computation of the minimum.
 trait Minimum: Copy {
     fn min(self, rhs: Self) -> Self;
 }
 
+impl<T: Minimum> Minimum for SomethingOrNothing<T> {
+    fn min(self, rhs: Self) -> Self {
+        match (self, rhs) {
+            (SomethingOrNothing::Nothing, SomethingOrNothing::Nothing) => {
+                SomethingOrNothing::Nothing
+            }
+            (SomethingOrNothing::Something(lhs), SomethingOrNothing::Something(rhs)) => {
+                SomethingOrNothing::Something(lhs.min(rhs))
+            }
+            (SomethingOrNothing::Nothing, SomethingOrNothing::Something(rhs)) => {
+                SomethingOrNothing::Something(rhs)
+            }
+            (SomethingOrNothing::Something(lhs), SomethingOrNothing::Nothing) => {
+                SomethingOrNothing::Something(lhs)
+            }
+        }
+    }
+}
+
 // i32 is Copyable as a very basic type as f32, f64, etc.
 // Arrays for example are not copyable.
 impl Minimum for i32 {
@@ -58,10 +85,7 @@ fn find_min<T: Minimum>(tab: [T; SIZE]) -> ([T; SIZE], SomethingOrNothing<T>) {
     let mut min = SomethingOrNothing::Nothing;
     // Here is T is not Copyable tab is consumed and cannot be returned
     for t in tab {
-        match min {
-            SomethingOrNothing::Nothing => min = SomethingOrNothing::Something(t),
-            SomethingOrNothing::Something(val) => min = SomethingOrNothing::Something(val.min(t)),
-        }
+        min = min.min(SomethingOrNothing::Something(t));
     }
     (tab, min)
 }