modifications pour types avances et modules

modules.md

@@ -38,6 +38,7 @@ sansfont: Sans Serif
 ## La définition d'un module
 
 - Dans le fichier `lib.rs` on peut à présent créer un/deux/... modules contenant une fonction
+
 	```{.lang-rust}
 	mod mon_module { // on peut même insérer d'autres modules à l'intérieur
 		fn ma_fonction() {
@@ -54,7 +55,7 @@ sansfont: Sans Serif
 
 - Les fonctions `mon_module::ma_fonction()`{.lang-rust}, `mon_autre_module::ma_fonction()`{.lang-rust} auront une signification (et une fonctionalité différente).
 
-## Fichiers (1/2)
+## Fichiers (1/3)
 
 - Avoir tous ses modules dans un fichier: pas pratique.
 - On *déclare* les modules dans `src/lib.rs`, on met le contenu dans `src/mon_module.rs`
@@ -83,7 +84,7 @@ sansfont: Sans Serif
 	}
 	```
 
-## Fichiers (2/2)
+## Fichiers (2/3)
 
 - On peut aller encore plus loin: `src/lib.rs`
 
@@ -125,3 +126,29 @@ sansfont: Sans Serif
 			unimplemented!(); // macro très pratique!
 		}
 		```
+
+## Fichiers (2/3)
+
+- Avec la structure de module suivante
+
+	```{.lang-rust}
+	mod mon_module {
+		fn ma_fonction() {
+			unimplemented!(); // macro très pratique!
+		}
+
+		mod mon_autre_module {
+			fn ma_fonction() { 
+				unimplemented!(); // macro très pratique!
+			}
+		}
+	}
+
+	```
+
+- On accède aux deux `ma_fonction()` avec 
+	
+	```{.lang-rust}
+	mon_module::ma_fonction();
+	mon_module::mon_autre_module::ma_fonction();
+	```
\ No newline at end of file

types_avances.md

@@ -6,52 +6,6 @@ author: Orestis Malaspinas
 sansfont: Sans Serif
 ---
 
-# $N$-uplets
-
-## `Tuples`{.rust}
-
-- Un $n-$tuplet est une *collection* ordonnée de $n$ objets.
-- Permet de regrouper plusieurs valeurs avec différents types dans un type composé.
-
-    <pre><code data-trim="hljs rust" class="lang-rust">
-    fn main() {
-        let tuple: (f64, char, usize) = (1.0, 'c', 18usize); // type pas nécessaire
-
-        println!("Un tuple {:?}", tuple); // affichage Debug
-
-        let sans_type_tuple = (666, "abcdef"); // type inféré
-
-        println!("Un autre tuple {:?}", sans_type_tuple); // affichage Debug
-  }
-    </code></pre>
-
-## Destructuration
-
-- Les $n$ objets d'un $n$-uple n'ont pas d'identifiant, juste un numéro.
-- On peut destructurer un $n$-uplet avec la notation
-
-  `let (a,b,c,...) = tuple;`{.rust}
-
-- Les champs sont accessibles avec la notation 
-
-  `
-  let a = tuple.0;
-  let b = tuple.1;
-  `{.rust}
-
-<pre><code data-trim="hljs rust" class="lang-rust">
-fn main() {
-    let tuple = (1.0, 'c', 18usize);
-    let (fl, ch, us) = tuple;
-    println!("Le tuple destructuré: {}, {}, {}", fl, ch, us);
-
-    let fl_ind = tuple.0;
-    let ch_ind = tuple.1;
-    let us_ind = tuple.2;
-    println!("Le tuple re-destructuré: {}, {}, {}", fl_ind, ch_ind, us_ind); 
-}
-</code></pre>
-
 # Vecteurs statiques
 
 ## `array`{.rust}
@@ -59,7 +13,7 @@ fn main() {
 - Collection d'objet de **même** type dont le nombre est connu à la compilation.
 - Ne peuvent pas changer de taille au cours de l'exécution (les éléments peuvent changer de valeur).
 - Éléments alloués contigument dans la mémoire. <!-- Ajouter image -->
-- Alloués sur la pile.
+- Alloués sur la pile (en général).
 
 <pre><code data-trim="hljs rust" class="lang-rust">
 fn main() {
@@ -109,6 +63,77 @@ fn main() {
 }
     </code></pre>
 
+# $N$-uplets
+
+## `Tuples` {.rust}
+
+- Un $n-$tuplet est une *collection* ordonnée de $n$ objets.
+
+    ```
+    let tuple: (type1, type2, ...) = (val1, val2, ...); // le type peut être inféré
+    ```
+- Permet de regrouper plusieurs valeurs avec différents types dans un type composé.
+
+    <pre><code data-trim="hljs rust" class="lang-rust">
+    fn main() {
+        let tuple: (f64, char, usize) = (1.0, 'c', 18usize); // type pas nécessaire
+
+        println!("Un tuple {:?}", tuple); // affichage Debug
+
+        let sans_type_tuple = (666, "abcdef"); // type inféré
+
+        println!("Un autre tuple {:?}", sans_type_tuple); // affichage Debug
+  }
+    </code></pre>
+- Pas forcément toujours pratique: on a pas d'identifiant pour les champs.
+
+## Exemple
+
+<pre><code data-trim="hljs rust" class="lang-rust">
+fn area(w: usize, h: usize) -> usize {
+    w * h
+}
+
+fn area_t(r: (usize, usize)) -> usize {
+    r.0 * r.1
+}
+
+fn main() {
+    let w = 10; 
+    let h = 20;
+
+    println!("Area = {}.", area(w,h));
+    println!("Area with tuple = {}.", area_t((w,h)));
+}
+</code></pre>
+
+## Destructuration
+
+- Les $n$ objets d'un $n$-uple n'ont pas d'identifiant, juste un numéro.
+- On peut destructurer un $n$-uplet avec la notation
+
+  `let (a,b,c,...) = tuple;`{.rust}
+
+- Les champs sont accessibles avec la notation 
+
+  `
+  let a = tuple.0;
+  let b = tuple.1;
+  `{.rust}
+
+<pre><code data-trim="hljs rust" class="lang-rust">
+fn main() {
+    let tuple = (1.0, 'c', 18usize);
+    let (fl, ch, us) = tuple;
+    println!("Le tuple destructuré: {}, {}, {}", fl, ch, us);
+
+    let fl_ind = tuple.0;
+    let ch_ind = tuple.1;
+    let us_ind = tuple.2;
+    println!("Le tuple re-destructuré: {}, {}, {}", fl_ind, ch_ind, us_ind); 
+}
+</code></pre>
+
 # Structures
 
 ## `struct`{.rust} (1/3)
@@ -217,7 +242,7 @@ let ins2 = TypeEnum::id2;
 
 ## `Enum`{.rust} (2/2)
 
-- On peut également associées avec n'importe quel variante de l'enum.
+- On peut également associer des valeurs avec n'importe quel variante de l'enum.
 
 <pre><code data-trim="hljs rust">
 struct TypeStruct {
@@ -235,11 +260,12 @@ let ins2 = TypeEnum::id2;
 let ins2 = TypeEnum::id3(TypeStruct::new());
 </code></pre>
 
-## Pattern matching, `match`{.rust}
+# Pattern matching
+
+## `match`{.rust} (1/3) 
 
 - Structure de contrôle extrêmement puissante.
-- Comparaison entre une valeurs et une série de *patterns* <!-- TODO traduire -->
-afin de décider d'une action à effectuer.
+- Comparaison entre une valeurs et une série de *patterns* afin de décider d'une action à effectuer.
 - Toutes les possibilités sont obligatoirement traitées.
 
 <pre><code data-trim="hljs rust" class="lang-rust">
@@ -261,7 +287,7 @@ afin de décider d'une action à effectuer.
 }
 </code></pre>
 
-## Pattern matching, `match`{.rust}
+## `match`{.rust} (2/3)
 
 - Dans certains cas, on veut le même comportement pour plusieurs `patterns`.
 
@@ -283,7 +309,27 @@ afin de décider d'une action à effectuer.
 }
 </code></pre>
 
-## Options
+## `match`{.rust} (3/3)
+
+- Pour lier une valeur stockée dans un `Enum`{.rust}
+
+<pre><code data-trim="hljs rust">
+enum AnimalMythique {
+    Chupacabra,
+    Dahu,
+    ChevalAile(Pays), // Le type Pays est défini avant
+}
+
+fn pays_dorigine(animal: AnimalMythique) {
+    match animal {
+        AnimalMythique::Chpacabra => println!("Mexique", pays),
+        AnimalMythique::Dahu => println!("Suisse", pays), // Oui il Suisse.
+        AnimalMythique::ChevalAile(pays) => println!("{}", pays);
+    },
+}
+</code></pre>
+
+# Options
 
 - Un type énuméré particulièrement utile est le type `Option`{.rust}
 ```{.lang-rust}