added rayon and clone

presentation/codes/ex_rayon/Cargo.toml

+[package]
+name = "ex_rayon"
+version = "0.1.0"
+authors = ["Orestis Malaspinas <orestis.malaspinas@hesge.ch>"]
+edition = "2018"
+
+[dependencies]
+rayon = "1.0"
\ No newline at end of file

presentation/codes/ex_rayon/src/main.rs

+extern crate rayon;
+
+use rayon::iter::IntoParallelRefIterator; 
+use rayon::iter::ParallelIterator;
+
+fn sum_counter(v: &Vec<i32>) -> (i32, i32) {
+    let mut counter = 0;
+    // let res = v.iter().map(|&vi| {
+    let res = v.par_iter().map(|&vi| {
+        counter += 1;
+        vi * vi
+    }).sum();
+    (res, counter)
+
+}
+
+fn main() {
+    let v = vec![1, 2, 3, 4, 5, 6, 7, 8];
+
+    let res: i32 = v.iter().map(|&vi| vi * vi).sum();
+    let res: i32 = v.par_iter().map(|&vi| vi * vi).sum();
+
+    println!("res = {}", res);
+
+    println!("res, counter = {:?}", sum_counter(&v));
+}

presentation/intro.md

@@ -381,6 +381,63 @@ Garantissent (presque toujours):
 - En bon Rust ils doivent être rares (4% du code de `rustc`).
 - Exemple : `raw pointer`
 
+## `raw pointers` (1/2)
+
+- Créer un `raw pointer` est sûr
+
+<pre><code data-trim="hljs rust" class="lang-rust">
+fn main() {
+	let x = 5;
+	let raw = &x as *const i32;
+
+	let mut y = 10;
+	let raw_mut = &mut y as *mut i32;
+}
+</code></pre>
+
+## `raw pointers`
+
+- Le déréférencer est dangereux
+
+<pre><code data-trim="hljs rust" class="lang-rust">
+fn main() {
+	let x = 5;
+	let raw = &x as *const i32;
+
+	println!("raw points at {}", *raw);
+}
+</code></pre>
+
+# Généricité
+
+## Traits
+
+- Interface, classe abstraite, classe virtuelle, ...
+- Implémentés pour un type.
+
+<pre><code data-trim="hljs rust" class="lang-rust">
+trait Clone { // déclaration de l'interface
+	// &self -> référence du receveur
+	// Self -> type qui implémente le trait
+
+	fn clone(&self) -> Self;
+}
+
+// T est générique
+// on doit donner des contraintes 
+// on sait que le type implémente Clone
+impl<T: Clone> Clone for Vec<T> {
+	fn clone(&self) -> Self {
+		let mut v = Vec::new();
+		for elem in self { 
+			// elem devient une référence vers chaque élément de self
+			v.push(elem.clone());
+		}
+		return v;
+	}
+}
+</code></pre>
+
 # Fearless concurrency
 
 ## Data race
@@ -557,9 +614,63 @@ Ce qui se passe en mémoire
 - Les primitives que nous venons de voir sont les seules disponibles dans la `std`.
 - Pour "plus": `rayon` ou `crossbeam` par exemple.
 
+## `rayon` (1/2)
+
+Librairie haut niveau pour faire du parallélisme:
+
+- Permet de paralléliser automatiquement les itérateurs: `iter`->`par_iter`.
+
+<pre><code data-trim="hljs rust" class="lang-rust">
+extern crate rayon;
+
+use rayon::iter::IntoParallelRefIterator; 
+use rayon::iter::ParallelIterator;
+
+fn main() {
+    let v = vec![1, 2, 3, 4, 5, 6, 7, 8];
+
+    let res: i32 = v.iter().map(|&vi| vi * vi).sum();
+    // let res: i32 = v.par_iter().map(|&vi| vi * vi).sum();
+
+    println!("res = {}", res);
+}
+
+</code></pre>
+
+## `rayon` (2/2)
+
+Librairie haut niveau pour faire du parallélisme:
+
+- Conserve **toutes** les garanties de sécurité!
+
+<pre><code data-trim="hljs rust" class="lang-rust">
+extern crate rayon;
+
+use rayon::iter::IntoParallelRefIterator; 
+use rayon::iter::ParallelIterator;
+
+fn main() {
+    let v = vec![1, 2, 3, 4, 5, 6, 7, 8];
+
+	let mut counter = 0;
+    let res: i32 = v.iter().map(|&vi| {
+		counter += 1;
+		vi * vi
+	}).sum();
+
+	// let res: i32 = v.par_iter().map(|&vi| {
+	// 	counter += 1;
+	// 	vi * vi
+	// }).sum();
+
+    println!("res = {}", res);
+}
+</code></pre>
+
 # Et beaucoup plus
 
 - Gestion d'erreurs: `Option`, `Result`.
+- Généricité.
 - Tests ("documentation testing").
 - Benchmarks (`nightly only`).
 - *Hygienic* `macros!`.