ajout adapter

iterators.md

@@ -109,9 +109,79 @@ fn main() {
     println!("{:?}", fib.next());
 
     let fib4 = fib.take(4); // retourne les 4 prochains éléments de l'itérateur
-    
     for i in fib4 {
         println!("{}", i);
     }
 }
 </code></pre>
+
+## Utilisations des itérateurs
+
+- Un itérateur donne une séquence de valeurs.
+- Un **adaptateur d'térateur** (iterator adapter) qui s'applique sur un itérateur produisant un nouvel itérateur.
+- Un **consommateur** qui s'applique sur un adaptateur rendant un ensemble de valeurs et "détruisant" l'itérateur.
+
+# Consommateur d'itérateur
+
+Un consommateur "consomme" un itérateur et retourne une (ou un ensemble) de valeurs.
+- `.collect()`{.rust}, `.find()`{.rust}, `.fold()`{.rust}, ...
+
+## Exemples (1/2)
+
+<pre><code data-trim="hljs rust" class="lang-rust">
+fn main() {
+    let v = vec![0, 4, 7, 9, 15];
+
+    let v_iter = v.iter();
+    let sum: i32 = v_iter.sum(); // l'itérateur est détruit et on a calculé la somme des éléments
+    println!("La somme est un consommateur: {}", sum);
+    // println!("L'itérateur: {:?}", v_iter);
+}
+</code></pre>
+
+## Exemples (2/2)
+
+<pre><code data-trim="hljs rust" class="lang-rust">
+fn main() {
+    let v = 0..10;
+    let v_vec = v.collect::&lt;Vec&lt;i32&gt;&gt;(); // l'itérateur est détruit et transformé en Vec
+    println!("Iter {:?}", v_vec);
+    // println!("Range {:?}", v);
+}
+</code></pre>
+
+# Adaptateur d'itérateur
+
+Un adaptateur "adapte" un itérateur et retourne un itérateur.
+
+## Exemples (1/2)
+
+- `.map()`{.rust} prend une fonction anonyme (closure) en paramètre et l'applique à chaque élément.
+
+<pre><code data-trim="hljs rust" class="lang-rust">
+fn main() {
+    let v = vec![0, 4, 7, 9, 15];
+
+    // iter() retourne un itérateur vers des références de v
+    v.iter().map(|x| x + 1).map(|y| println!("{}", y)); // n'est pas consommé, rust ne fera rien ("lazy").
+    let add_v: Vec&lt;i32&gt; = v.iter().map(|x| x + 1).collect();
+    println!("{:?}", add_v);
+}
+</code></pre>
+
+## Exemples (2/2)
+
+- `.filter()`{.rust} prend prédicat et retourne un itérateur satisfaisant le prédicat.
+
+<pre><code data-trim="hljs rust" class="lang-rust">
+fn main() {
+    let v = vec![0, 4, 7, 9, 15];
+
+    // into_iter() retourne un itérateur vers les valeurs de v (v disparaît)
+    let fil_v: Vec&lt;i32&gt; = v.into_iter().filter(|x| *x > 7).collect();
+    println!("{:?}", fil_v);
+    // let fil_t2_v: Vec&lt;i32&gt; = v.into_iter().filter(|x| *x > 7).map(|y| 3*y).collect();
+    // println!("{:?}", fil_v);
+}
+</code></pre>
+