diff --git a/book/src/part10.md b/book/src/part10.md
index f43e22ad25e79db7e1209324736e226162f795e0..02d6fca5660907ea1959c68b13fe9e4e073cd189 100644
--- a/book/src/part10.md
+++ b/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.
 
diff --git a/codes/rust_lang/part10/src/find.rs b/codes/rust_lang/part10/src/find.rs
index 1934d0b367d192f49db927ed8cd21633eb2a0e7e..8b0e6e3a5a6ebcd5c5df41063eb1d6a9a773d732 100644
--- a/codes/rust_lang/part10/src/find.rs
+++ b/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