Suggestion Orestis

book/src/part10.md

@@ -162,20 +162,36 @@ Nous aimerions trouver quel est l'élément le plus petit en valeur absolue d'un
 La première étape consiste à créer deux itérateurs. Le premier contient le signe de chaque élément
 et le deuxième, la valeur absolue de chaque élément.
 
+```rust,ignore
+{{#include ../../codes/rust_lang/part10/src/find.rs:find_absolute_minimum_1}}
+```
+
 Pour obtenir ces itérateurs, nous allons transformer nos itérateurs obtenus avec `iter()` en utilsant
 la fonction `map()`. Cette méthode permet d'appliquer une même transformation sur tous les éléments
 d'un itérateur. Pour l'itérateur `signs`, on appelle la méthode `signum()` des `i32`, qui retourne 1 si
 le nombre est positif, 0 si le nombre est 0 et -1 si le nombre est négatif. Pour `abs_values`,
 nous utilisons la méthode `abs()` des `i32`, qui retourne la valeur absolue d'un nombre.
 
+```rust,ignore
+{{#include ../../codes/rust_lang/part10/src/find.rs:find_absolute_minimum_2}}
+```
+
 Maintenant que nous avons nos deux itérateurs, nous aimerions pouvoir itérer sur les deux simultanément.
 Pour cela, nous pouvons utiliser la méthode `zip()`. Elle permet de transformer deux itérateurs, en un
 unique itérateur de tuple. Ici nous avons deux itérateurs de `i32`, qui deviennent donc un seul itérateur
 de type tuple `(i32, i32)`.
 
+```rust,ignore
+{{#include ../../codes/rust_lang/part10/src/find.rs:find_absolute_minimum_3}}
+```
+
 Ensuite avec `fold()`, il nous suffit de comparer les valeurs absolues et de retourner une option contenant
 le signe et la valeur absolue.
 
+```rust,ignore
+{{#include ../../codes/rust_lang/part10/src/find.rs:find_absolute_minimum_4}}
+```
+
 Pour finir, on utilise la méthode `map()` de notre `Option<(i32,i32)>` pour multiplier
 la valeur absolue par le signe. Ce qui nous donne au final une `Option<i32>` contenant notre résultat.
 

codes/rust_lang/part10/src/find.rs

@@ -80,10 +80,15 @@ pub fn find_even_minimum(v: &Vec<i32>) -> Option<i32> {
 /// ```
 // ANCHOR: find_absolute_minimum
 pub fn find_absolute_minimum(v: &Vec<i32>) -> Option<i32> {
+    // ANCHOR: find_absolute_minimum_1
     let signs = v.iter().map(|i| i.signum());
     let abs_values = v.iter().map(|i| i.abs());
+    // ANCHOR_END: find_absolute_minimum_1
+    // ANCHOR: find_absolute_minimum_2
     signs
         .zip(abs_values)
+        // ANCHOR_END: find_absolute_minimum_2
+        // ANCHOR: find_absolute_minimum_3
         .fold(None, |acc, (c_sign, c_abs_v)| {
             let next_acc = if let Some((sign, abs_v)) = acc {
                 if abs_v <= c_abs_v {
@@ -96,6 +101,9 @@ pub fn find_absolute_minimum(v: &Vec<i32>) -> Option<i32> {
             };
             Some(next_acc)
         })
+        // ANCHOR_END: find_absolute_minimum_3
+        // ANCHOR: find_absolute_minimum_4
         .map(|(sign, abs_v)| sign * abs_v)
+    // ANCHOR_END: find_absolute_minimum_4
 }
 // ANCHOR_END: find_absolute_minimum