diff --git a/iterators.md b/iterators.md index ba40d4e2b4c99d9b93073dffb6d4f1adc1dfb257..0142fcbbdf65296142d7dc05bf22eacf7a587383 100644 --- a/iterators.md +++ b/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> \ No newline at end of file +</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::<Vec<i32>>(); // 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<i32> = 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<i32> = v.into_iter().filter(|x| *x > 7).collect(); + println!("{:?}", fil_v); + // let fil_t2_v: Vec<i32> = v.into_iter().filter(|x| *x > 7).map(|y| 3*y).collect(); + // println!("{:?}", fil_v); +} +</code></pre> +