diff --git a/types.md b/types.md
index a83fa1d2237145b3f57f39410045d032057861fe..826fc30b03ab80d5d2310430b61036efac7290cd 100644
--- a/types.md
+++ b/types.md
@@ -45,6 +45,7 @@ sansfont: Sans Serif
     - Les booléens.
     - Les charactères.
 
+# Les types numériques
 
 ## Les entiers (1/3)
 
@@ -126,25 +127,63 @@ fn main() {
 - On ne peut **pas** convertir implicitement d'un type à un autre.
 
     <pre><code data-trim="hljs rust" class="lang-rust">
-    fn main() {
-        let x:f64 = 3.14159265359f32; // flottant 32 bits en flottant 64 bits
-    }
+fn main() {
+    let x:f64 = 3.14159265359f32; // flottant 32 bits en flottant 64 bits
+}
     </code></pre>
 
 - On peut convertir entre les types de base avec `as`{.rust}.
 
     <pre><code data-trim="hljs rust" class="lang-rust">
-    fn main() {
-        let x = 3.14159265359f64 as f32; // flottant 64 bits en flottant 32 bits
+fn main() {
+    let x = 3.14159265359f64 as f32; // flottant 64 bits en flottant 32 bits
 
-        println!("Conversion de pi en 32 bits, x = {}.", x); // affichage
+    println!("Conversion de pi en 32 bits, x = {}.", x); // affichage
 
-        let y = 3.14159265359f64 as isize; // flottant 64 bits en entier 
+    let y = 3.14159265359f64 as isize; // flottant 64 bits en entier 
 
-        println!("Conversion de pi en entier 64 bits, y = {}.", y); // affichage
-    }
+    println!("Conversion de pi en entier 64 bits, y = {}.", y); // affichage
+}
     </code></pre>
 
+## Les opérations arithmétiques
+
+- Toutes les opérations arithmétiques standard: `+, -, *, /, %`{.rust}
+
+<pre><code data-trim="hljs rust" class="lang-rust">
+fn main() {
+    let addition = 3 + 8;
+    println!("La valeur de l'addition est: {}", addition);
+
+    let soustraction = 3.5 - 8.1;
+    println!("La valeur de la soustraction est: {}", soustraction);
+
+    let multiplication = -3.33 * 3.33;
+    println!("La valeur de la multiplication est: {}", multiplication);
+
+    let division = 7 / 2; // division entière
+    println!("La valeur de la division est: {}", division);
+}
+</code></pre>
+
+## Assignations
+
+- Opérations arithmétiques et assignations: `+=, -=, *=, /=, %=`{.rust}.
+
+<pre><code data-trim="hljs rust" class="lang-rust">
+fn main() {
+    let mut addition = 3;
+    addition += 5;
+    println!("La valeur de l'addition est: {}", addition);
+
+    let mut multiplication = 3.5;
+    multiplication *= - 8.1;
+    println!("La valeur de la multiplication est: {}", multiplication);
+}
+</code></pre>
+
+# Les types booléens
+
 ## Les booléens
 
 - Une variable booléenne est de type `bool`{.rust}.
@@ -152,19 +191,43 @@ fn main() {
     - `true`{.rust}
     - `false`{.rust}
 - La façon typique d'utiliser les booléens sont les structures de contrôle: `if`{.rust}, `while`{.rust}, ...
+- Peut se convertir en entier (l'inverse est faux).
 
 <pre><code data-trim="hljs rust" class="lang-rust">
 fn main() {
     let x = true; // Booléen inféré vrai
-
     println!("La variable x est {}.", x); // affichage
 
     let x: bool = false; // Booléen faux
-
     println!("La variable x est {}.", x); // affichage
+
+    let x = false as i32; // Booléen faux
+    let y = true as i32; // Booléen faux
+    println!("False est {}, et True est {}.", x, y); // affichage
 }
 </code></pre>
 
+## Les opérations booléennes
+
+- Comparaisons logiques `==, !=, &&, ||, <, >, <=, >=`{.rust}
+
+    <pre><code data-trim="hljs rust" class="lang-rust">
+fn main() {
+    let x = 3;
+    let y = 8;
+    println!("{} est-il égal à {}? {}", x, y, x == 8);
+    println!("{} est-il différent de {}? {}", x, y, x != 8);
+}
+    </code></pre>
+
+- Comparaisons bit à bit:
+    - Et: `&`{.rust}
+    - Ou: `^`{.rust}
+
+- Comparaisons bit à bit et assignations: `&=, ^=`{.rust}.
+
+# Le type charactère
+
 ## Les charactères
 
 - Une variable de type **charactère** est notée `char`{.rust}.
@@ -184,9 +247,9 @@ fn main() {
 }
 </code></pre>
 
-## Types composés
+# Les types composés
 
-- On peut contruire des types plus complexes (composés) à partir de ces types de base:
+- On peut contruire des types plus complexes (composés) à partir de types de base que nous venons de voir:
     - La type `Struct`{.rust}
     - Le type `Tuple`{.rust}
     - Le type `Enum`{.rust}
@@ -194,46 +257,4 @@ fn main() {
     - Le type `Vec`{.rust}
     - Le type `String`{.rust}
     - ... 
-
-
-# Les opérations
-
-## Les opérations mathémqtiques
-
-- Toutes les opérations mathématiques standards existent: `+, -, *, /`{.rust}
-
-    <pre><code data-trim="hljs rust" class="lang-rust">
-fn main() {
-    let addition = 3 + 8;
-    println!("La valeur de l'addition est: {}", addition);
-
-    let soustraction = 3.5 - 8.1;
-    println!("La valeur de la soustraction est: {}", soustraction);
-
-    let multiplication = -3.33 * 3.33;
-    println!("La valeur de la multiplication est: {}", multiplication);
-
-    let division = 7 / 2;
-    println!("La valeur de la soustraction est: {}", division);
-}
-    </code></pre>
-
-## Conversions
-
-- Il est impossible d'effectuer des opérations entre des types non-compatibles
-
-    <pre><code data-trim="hljs rust" class="lang-rust">
-fn main() {
-    let addition = 3 + 8.0;
-    println!("La valeur de l'addition est: {}", addition);
-}
-    </code></pre>
-
-    <pre><code data-trim="hljs rust" class="lang-rust">
-fn main() {
-    let addition = 3i32 + 8i64;
-    println!("La valeur de l'addition est: {}", addition);
-}
-    </code></pre>
-
-## Les opérations booléennes
\ No newline at end of file
+    
\ No newline at end of file