push for review

Author: JulienBerkane

courses/rust_essentials/100_generics.rst

@@ -34,6 +34,6 @@ Generics
 
 .. include:: 100_generics/01_introduction.rst
 .. include:: 100_generics/02_generics.rst
-.. include:: 100_generics/03_generics_and_traits.rst
+.. include:: 100_generics/03_constraints_and_properties.rst
 .. include:: 100_generics/98_lab.rst
 .. include:: 100_generics/99_summary.rst

courses/rust_essentials/100_generics/01_introduction.rst

@@ -6,13 +6,13 @@ Introduction
 Topics Covered
 ----------------
 
--  **Generic data types**
+-  **Generic Data Types**
 
    -  Definition and instantiation
 
--  **Constraints and properties** 
+-  **Constraints and Properties** 
 
--  **Generic traits**
+-  **Generic Traits**
 
 
 -------------------------
@@ -31,7 +31,7 @@ The Notion of a Pattern
 		(right, left) 
 	}
 
-* It would be nice to extract these properties in some common pattern, and then just replace the parts that need to be replaced
+*  A common pattern can be extracted, with only some parts to replace
 
 .. code:: Rust
 

courses/rust_essentials/100_generics/02_generics.rst

@@ -19,14 +19,11 @@ Generic Data Type
    fn Swap<T> (l: T, r: T) -> (T, T) {
 		(r, l)
 }
-
 
 -  :rust:`T` (the generic type parameter) means an :rust:`Swap` can wrap any type
 
    -  :rust:`Swap<i32>`, :rust:`Swap<f64>` etc
 
-
-
 ------------
 Be Generic
 ------------
@@ -68,7 +65,6 @@ Constructs that can be made generic
 -- JBE : very all options are present in examples 
 -- Add Examples ?
 
-
 ----------------
 Type Inference 
 ----------------
@@ -92,7 +88,6 @@ Type Inference
 
 -  Type is **infered** at compile-time from the context
 
-
 -----------------------
 Multiple Generic Type
 -----------------------
@@ -109,9 +104,4 @@ Constructs can have multiple generic data types
     let both_integer = Point { x: 5, y: 10 };
     let both_float = Point { x: 1.0, y: 4.0 };
     let integer_and_float = Point { x: 5, y: 4.0 };
-    
-	
-
-
-
-
+    

courses/rust_essentials/100_generics/03_constraints_and_properties.rst

@@ -23,7 +23,6 @@ Trait Bounds
 		println!("{}", item); // Only works if 'T' implements Display
 	}
 
-
 --------------------
 Adding Constraints
 --------------------
@@ -37,7 +36,7 @@ Adding a trait to a generic object gives it more functionalities
 		item < 10 
 	}
 
-:error:`ERROR: "binary operation '<' cannot be applied to type 'T'"`	
+:error:`error[E0369]: binary operation '<' cannot be applied to type 'T'`	
 
 .. code:: rust
 
@@ -73,7 +72,7 @@ Satisfying Constraints
 Trait Bounds Generics
 -----------------------
 
--  User defined traits can be constraints for a generic function
+-  User-defined traits can be constraints for a generic function
 
 .. code:: rust
 
@@ -140,8 +139,6 @@ Multiple Traits
         U: Debug + PartialOrd 
     { ... }
 
-
-
 ----------------
 Generic Traits
 ----------------
@@ -163,9 +160,8 @@ Generic Traits
 	}
 	// Rule for converting Minutes to a String
 	impl Transform<String> for Minutes {
-		fn convert(&self) -> String { format!("{} minutes", self.0) }
+		fn convert(&self) -> String { format!("{} min", self.0) }
 	
-
 -----------------------------
 "derive" Macro and Generics
 -----------------------------
@@ -192,5 +188,4 @@ Generic Traits
 		// Secret doesn't implement Debug, derive macro fails
 	}
 :error:`ERROR: "Box<Secret> doesn't implement Debug"`	
-	
-
+	

courses/rust_essentials/100_generics/03_generics_and_traits.rst

@@ -0,0 +1,196 @@
+============================
+Constraints and Properties
+============================
+
+--------------
+Trait Bounds
+--------------
+
+-  Generic data :rust:`<T>` has almost no limitations
+
+-  Compiler will restrict what can be done with :rust:`<T>` 
+   -  Doesn't know if it can do math, order or anything else 
+   
+-  Traits are the **fine print** on a generic **contract**
+
+   -  Ensure the logic only executes on types that "fit" the requirements
+   
+-  Added in the :rust:`<>` next to the type
+
+.. code:: rust
+
+	fn print_it<T: std::fmt::Display>(item: T) {
+		println!("{}", item); // Only works if 'T' implements Display
+	}
+
+
+--------------------
+Adding Constraints
+--------------------
+
+Adding a trait to a generic object gives it more functionalities
+
+.. code:: rust
+
+	// Compiler: "What if T is a name? Is 'Bob' < 10?"
+	fn is_small<T>(item: T) -> bool {
+		item < 10 
+	}
+
+:error:`ERROR: "binary operation '<' cannot be applied to type 'T'"`	
+
+.. code:: rust
+
+	fn smaller<T: PartialOrd>(item: T, max_v: T) -> bool {
+		item < max_v  
+	}
+
+------------------------
+Satisfying Constraints
+------------------------
+
+-  Adding a trait restrict types that satisfy the generic contract
+
+.. code:: rust
+
+	struct Vegetable;
+
+	fn smaller<T: PartialOrd>(item: T, threshold: T) -> bool {
+		item < threshold  
+	}
+
+	fn main() {
+		let potato : Vegetable;
+		let sweet_potato : Vegetable;
+		println!("{}", smaller(5, 10));      
+		println!("{}", smaller(1.5, 10.0));  
+		println!("{}", smaller(potato , sweet_potato));	 
+	}
+
+:error:`error[E0277]: can't compare 'vegetable' with 'vegetable'`
+
+-----------------------
+Trait Bounds Generics
+-----------------------
+
+-  User defined traits can be constraints for a generic function
+
+.. code:: rust
+
+    trait Speak {
+        fn say_hello(&self);
+    }
+    
+    struct Dog;
+    
+    impl Speak for Dog {
+        fn say_hello(&self) {
+            println!("Woof!");
+        }
+    }
+    
+    // This function ONLY accepts types that can 'Speak'
+    fn make_it_speak<T: Speak>(item: T) {
+        item.say_hello();
+    }
+    
+    fn main() {
+        let pet = Dog;
+        make_it_speak(pet); // Output: Woof!
+    }
+
+------------------
+Turbofish "::<>"
+------------------
+
+-  Usually the compiler determines the type to use from context
+
+   -  Sometimes there is *ambiguity*
+   
+.. code:: rust
+    
+	// Vec<T> is a generic struct
+	// Vec defines an associated function called 'new'
+    // Error: "type annotations needed"	
+    // The compiler knows it's a Vec, but a Vec of what?
+    let x = Vec::new();
+	
+-  The turbofish :rust:`::<>` syntax is used to dispell ambiguity
+
+.. code:: rust
+
+    // The Turbofish dispels the mystery!
+    let x = Vec::<i32>::new();
+
+-----------------
+Multiple Traits
+-----------------
+
+-  Can have multiple trait bounds
+
+   -  Using the :rust:`+` operator
+
+-  :rust:`where` clause can be used for better visibility
+
+.. code:: rust
+
+	fn complex_function<T, U>(t: T, u: U) 
+    where 
+        T: Display + Clone, 
+        U: Debug + PartialOrd 
+    { ... }
+
+
+
+----------------
+Generic Traits
+----------------
+
+-  Traits can be made generic
+
+   -  Allows the same trait to behave differently with each type
+
+.. code:: rust
+
+	// T is the "Target" type we want to turn into
+	trait Transform<T> {
+		fn convert(&self) -> T;
+	}
+	struct Minutes(i32);
+	// Rule for converting Minutes to Seconds
+	impl Transform<i32> for Minutes {
+		fn convert(&self) -> i32 { self.0 * 60 }
+	}
+	// Rule for converting Minutes to a String
+	impl Transform<String> for Minutes {
+		fn convert(&self) -> String { format!("{} minutes", self.0) }
+	
+
+-----------------------------
+"derive" Macro and Generics
+-----------------------------
+
+-  :rust:`derive` macro can be used on generic struct using standard traits
+
+   -  Can't be used on generic traits
+   
+.. code:: rust
+    
+	// Compiler assumes T has 'Debug' trait
+	#[derive(Debug)]
+	struct Box<T> {
+		content: T,
+	}
+	struct Secret; // Note: No Debug here
+
+	fn main() {
+		let good_box = Box { content: 42 }; 
+		println!("{:?}", good_box); // Works (i32 is Debug)
+
+		let bad_box = Box { content: Secret };
+		// ERROR: "Box<Secret> doesn't implement Debug"
+		// Secret doesn't implement Debug, derive macro fails
+	}
+:error:`ERROR: "Box<Secret> doesn't implement Debug"`	
+	
+