added different things

control.md

@@ -25,7 +25,7 @@ sansfont: Sans Serif
 
 - Exemple:
 
-<pre><code data-trim="hljs rust" class="lang-rust">
+    <pre><code data-trim="hljs rust" class="lang-rust">
 fn main() {
     let x = 5; 
 
@@ -33,7 +33,7 @@ fn main() {
         println!("{} est plus petit que 10.", x);
     } 
 }
-</code></pre>  
+    </code></pre>  
 
 ## Le `if ... else`{.rust} 
 
@@ -54,7 +54,7 @@ fn main() {
 
 - Exemple:
 
-<pre><code data-trim="hljs rust" class="lang-rust">
+    <pre><code data-trim="hljs rust" class="lang-rust">
 fn main() {
     let x = 5; 
 
@@ -64,7 +64,7 @@ fn main() {
         println!("{} est plus grand ou égal à 10.", x);
     }
 }
-</code></pre>  
+    </code></pre>  
 
 
 ## Le `if ... else if ... else`{.rust} 
@@ -115,7 +115,7 @@ fn main() {
 
 - On sort d'une boucle avec `break`{.rust}
 
-<pre><code data-trim="hljs rust" class="lang-rust">
+    <pre><code data-trim="hljs rust" class="lang-rust">
 fn main() {
     let mut i = 0;
     loop {
@@ -129,13 +129,13 @@ fn main() {
         }
     }
 }
-</code></pre>  
+    </code></pre>  
 
 ## La boucle `while`{.rust}
 
 - Boucle conditionnelle: on remplace `loop, if, et break`{.rust} par `while`{.rust}.
 
-<pre><code data-trim="hljs rust" class="lang-rust">
+    <pre><code data-trim="hljs rust" class="lang-rust">
 fn main() {
     let mut i = 0;
     while i != 10 {
@@ -144,20 +144,20 @@ fn main() {
     }
     println!("Fin de la boucle!");
 }
-</code></pre>  
+    </code></pre>  
 
 ## La boucle `for`{.rust}
 
 - Encore plus concis que `while`{.rust}
 
-<pre><code data-trim="hljs rust" class="lang-rust">
+    <pre><code data-trim="hljs rust" class="lang-rust">
 fn main() {
     for i in 0..10 {
         println!("{}-ème boucle!", i);
     }
     println!("Fin de la boucle!");
 }
-</code></pre>  
+    </code></pre>  
 
 - La syntaxe permet d'itérer sur bien plus que juste des entiers, mais on verra ça plus tard.
 

types.md

@@ -193,4 +193,47 @@ fn main() {
     - Le type `Array`{.rust}
     - Le type `Vec`{.rust}
     - Le type `String`{.rust}
-    - ... 
\ No newline at end of file
+    - ... 
+
+
+# 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

variables.md

@@ -83,14 +83,14 @@ sansfont: Sans Serif
 - On peut déclarer une variable, puis l'initialiser en 2 étapes.
 
     <pre><code data-trim="hljs rust" class="lang-rust">
-    fn main() {
-        let x; // Déclaration
-        x = 5; // Assignation, on préfère écrire `let x = 5;`
-        println!("La valeur de x est: {}", x); // affichage
-
-        let y = "La valeur 5 est liée avec la variable x"; // Chaîne de caractères
-        println!("La valeur de y est: {}", y); // affichage
-    }
+fn main() {
+    let x; // Déclaration
+    x = 5; // Assignation, on préfère écrire `let x = 5;`
+    println!("La valeur de x est: {}", x); // affichage
+
+    let y = "La valeur 5 est liée avec la variable x"; // Chaîne de caractères
+    println!("La valeur de y est: {}", y); // affichage
+}
     </code></pre>
 
 ## Portée (1/2)
@@ -98,22 +98,22 @@ sansfont: Sans Serif
 - La portée d'une variable est le *bloc* dans lequel elle est déclarée (et tous les blocs inclus).
 
     <pre><code data-trim="hljs rust" class="lang-rust">
-    fn main() {
-        let x = 5; 
-        {
-            println!("La valeur de x est: {}", x);
-        }
+fn main() {
+    let x = 5; 
+    {
+        println!("La valeur de x est: {}", x);
     }
+}
     </code></pre>
     <pre><code data-trim="hljs rust" class="lang-rust">
-    fn main() {
-        {
-            let x = 5; 
-            println!("La valeur de x est: {}", x);
-        }
-
+fn main() {
+    {
+        let x = 5; 
         println!("La valeur de x est: {}", x);
     }
+
+    println!("La valeur de x est: {}", x);
+}
     </code></pre>
 
 ## Portée (2/2)
@@ -121,15 +121,15 @@ sansfont: Sans Serif
 - En redéclarant une variable dans un bloc intérieur on peut **masquer** la variable extérieure.
 
     <pre><code data-trim="hljs rust" class="lang-rust">
-    fn main() {
-        let x = 1000; 
-        {
-            let x = 5; 
-            println!("La valeur de x est: {}", x);
-        }
-
+fn main() {
+    let x = 1000; 
+    {
+        let x = 5; 
         println!("La valeur de x est: {}", x);
     }
+
+    println!("La valeur de x est: {}", x);
+}
     </code></pre>
 
 ## Mutabilité/**Immutabilité**
@@ -138,13 +138,13 @@ sansfont: Sans Serif
 - Une variable immutable **ne peut pas** être modifiée.
 - Si on essaie le compilateur refuser de compiler le programme.
     <pre><code data-trim="hljs rust" class="lang-rust">
-    fn main() {
-        let x = 5;
-        println!("La valeur de x est: {}", x);
+fn main() {
+    let x = 5;
+    println!("La valeur de x est: {}", x);
 
-        x = 6;
-        println!("La valeur de x est: {}", x);
-    }
+    x = 6;
+    println!("La valeur de x est: {}", x);
+}
     </code></pre>
 
 ## **Mutiabilité**/Immutabilité
@@ -154,13 +154,13 @@ sansfont: Sans Serif
     `let mut symbole = valeur`{.rust}.
 - Une variable mutable **peut** être modifiée.
     <pre><code data-trim="hljs rust" class="lang-rust">
-    fn main() {
-        let mut x = 5;
-        println!("La valeur de x est: {}", x);
+fn main() {
+    let mut x = 5;
+    println!("La valeur de x est: {}", x);
 
-        x = 6;
-        println!("La valeur de x est: {}", x);
-    }
+    x = 6;
+    println!("La valeur de x est: {}", x);
+}
     </code></pre>
 
 ## Constantes
@@ -176,10 +176,10 @@ sansfont: Sans Serif
     4. Valides durant toute la durée d'un programme.
 
     <pre><code data-trim="hljs rust" class="lang-rust">
-    const PI: f64 = 3.14159265359;
-    fn main() {
-        println!("La valeur de pi est: {}", PI);
-    }
+const PI: f64 = 3.14159265359;
+fn main() {
+    println!("La valeur de pi est: {}", PI);
+}
     </code></pre>
 
 ## Masquage
@@ -188,21 +188,24 @@ sansfont: Sans Serif
 - La nouvelle déclaration **masque** la précédente.
 
     <pre><code data-trim="hljs rust" class="lang-rust">
-    fn main() {
-        let x = 5;
-        let x = x + 1;
-        println!("La valeur de x est: {}", x);
-    }
+fn main() {
+    let x = 5;
+    let x = x + 1;
+    println!("La valeur de x est: {}", x);
+}
     </code></pre>
 
 - La nouvelle variable n'a pas forcément le même type que la variable d'origine¨.
 
     <pre><code data-trim="hljs rust" class="lang-rust">
-    fn main() {
-        let x = "La variable d'origine";
-        println!("La valeur de x est: {}", x);
-        let x = x.len();
-        println!("La valeur de x est: {}", x);
-    }
+fn main() {
+    let x = "La variable d'origine";
+    println!("La valeur de x est: {}", x);
+    let x = x.len();
+    println!("La valeur de x est: {}", x);
+}
     </code></pre>
 
+
+
+