annotations moved correctly

slides/src/control.md

@@ -36,7 +36,7 @@ fn main() {
 
 ## La boucle infinie: `loop`
 
-```rust [] ignore
+```rust ignore []
 fn main() {
     loop {
         println!("En boucle!");

slides/src/errors.md

@@ -9,7 +9,7 @@
 
 ## `panic!()`
 
-```rust [2-4|] should_panic
+```rust should_panic [2-4|]
 fn elem(v: &[i32], i: usize) -> i32 {
     if i >= v.len() {
         panic!("Erreur fatale!");
@@ -67,7 +67,7 @@ stack backtrace:
 
 ## Asserts
 
-```rust [4,6,7|] should_panic
+```rust should_panic [4,6,7|]
 fn main() {
     let num = 1;
     let denum = 0;
@@ -131,7 +131,7 @@ fn main() {
 
 ## Options: `unwrap()`
 
-```rust [11|] should_panic
+```rust should_panic [11|]
 fn div(num: i32, denum: i32) -> Option<i32> {
     if denum == 0 {
         None
@@ -179,7 +179,7 @@ fn main() {
 
 ## `unwrap()`
 
-```rust [10|] should_panic
+```rust should_panic [10|]
 fn elem(v: &[i32], i: usize) -> Result<i32, &str> {
     if i >= v.len() {
         return Err("L'index est trop grand!")
@@ -192,4 +192,4 @@ fn main() {
     let res = elem(&v, 100).unwrap();
     println!("L'élément est {}", res);
 }
-```
\ No newline at end of file
+```

slides/src/generics.md

@@ -27,7 +27,7 @@ fn main() {
 
 ## Exemple avec générique (concept)
 
-```rust [1|2|] compile_fail
+```rust compile_fail [1|2|]
 fn max<T>(a: T, b: T) -> T {
     if a > b { a } else { b }
 }                            
@@ -54,7 +54,7 @@ fn main() {
 
 ## Un seul type générique
 
-```rust [6-7|8|] compile_fail
+```rust compile_fail [6-7|8|]
 struct Point<T> {
     x: T,
     y: T,

slides/src/lifetimes.md

@@ -7,7 +7,7 @@
 
 ## Problématique
 
-```rust [2|3-6|7|] compile_fail
+```rust compile_fail [2|3-6|7|]
 fn main() {
     let r;
     {
@@ -20,7 +20,7 @@ fn main() {
 
 ## Durée de vie: annotation
 
-```rust [] compile_fail
+```rust compile_fail []
 fn main() {
     let r: &'a i32;        // --------+-- 'a
     {                      //         |
@@ -42,7 +42,7 @@ fn main() {
 
 ## Exemple
 
-```rust [8-13|1,7|] compile_fail
+```rust compile_fail [8-13|1,7|]
 fn longest(x: &str, y: &str) -> &str {
     if x.len() > y.len() {
         x
@@ -82,7 +82,7 @@ fn main() {
 * Ne permet pas d'augmenter une durée de vie,
 * Le compilateur vérifie que la durée de vie est **compatible** avec la durée de vie.
 
-```rust [] ignore
+```rust ignore []
 &T        // référence
 &'a T     // référence avec durée de vie a
 &'a mut T // référence mutable avec durée de vie a

slides/src/methods.md

@@ -45,7 +45,7 @@ fn main() {
 
 ## Le mot-clé `self`
 
-```rust [6-9|10-12|16-18|] compile_fail
+```rust compile_fail [6-9|10-12|16-18|]
 struct Rectangle {
     width: u32,
     height: u32,

slides/src/modules.md

@@ -55,7 +55,7 @@ fn main() {
 
 ## Le contenu d'un module est privé
 
-```rust [2-3,6|] compile_fail
+```rust compile_fail [2-3,6|]
 mod hepia {
     fn uni_automne() {
     }
@@ -114,7 +114,7 @@ ecole
 
 ## Les fichiers et visibilité
 
-```rust [1-3|4-6|7-8|9-10|11-12|13-17|] ignore
+```rust ignore [1-3|4-6|7-8|9-10|11-12|13-17|]
 // dans lib.rs
 pub mod hepia;
 pub mod heg;
@@ -153,4 +153,4 @@ pub
    | pub ( self )  // public dans le module courant
    | pub ( super ) // public dans le module parent
    | pub ( in path ) // public dans le path explicite
-```
\ No newline at end of file
+```

slides/src/ownership.md

@@ -117,7 +117,7 @@ fn main() {
 
 ## Changement de propriétaire: invalide
 
-```rust [7-8|9|] compile_fail
+```rust compile_fail [7-8|9|]
 fn main() {
     let mut y = Vec::new();
     for i in 0..5 {
@@ -167,7 +167,7 @@ fn main() {
 
 ## Lors du passage en paramètre à une fonction
 
-```rust [1-3,8|] compile_fail
+```rust compile_fail [1-3,8|]
 fn take_own(_v: Vec<i32>) {
 	// on fait des choses
 }
@@ -242,7 +242,7 @@ fn main() {
 
 ## Exemple 2
 
-```rust [1-4,10|] compile_fail
+```rust compile_fail [1-4,10|]
 fn get_len(v: &Vec<i32>) -> usize {
 	v.push(2); // on ajoute 2 à v
 	v.len()
@@ -281,7 +281,7 @@ fn main() {
 
 ## Sans la règle sur la référence mutable
 
-```rust [2|3|4|5-6|] compile_fail
+```rust compile_fail [2|3|4|5-6|]
 fn main() {
     let mut y = Vec::new();
     let z = &y;

slides/src/smart_pointers.md

@@ -68,7 +68,7 @@ fn main() {
 
 ## Cas pratique: la liste chaînée
 
-```rust [1,4|2-3|1-4|] compile_fail
+```rust compile_fail [1,4|2-3|1-4|]
 enum List {
 	Elem(i32, List),
 	Nil,

slides/src/types.md

@@ -48,7 +48,7 @@ fn main() {
 
 - La conversion implicite **n'existe pas**.
 
-```rust [2|] compile_fail
+```rust compile_fail [2|]
 fn main() {
     let x:i64 = 5i32; // entier 32 bits dans une variable 64 bits
 }
@@ -66,7 +66,7 @@ fn main() {
 ## Les entiers (3/3)
 
 - Le dépassement de capacité est **interdit**.
-```rust [4|] compile_fail
+```rust compile_fail [4|]
 fn main() {
     let x:i32 = 12345678; 
     let y:i32 = 12345678; 
@@ -84,7 +84,7 @@ fn main() {
 
 - On ne **peut pas** convertir implicitement d'un type à un autre.
 
-```rust [2|] compile_fail
+```rust compile_fail [2|]
 fn main() {
     let x:f64 = 3.14159265359f32; // flottant 32 bits en flottant 64 bits
 }

slides/src/types_avances.md

@@ -239,7 +239,7 @@ fn main() {
 
 ## `match`: bras manquant
 
-```rust [8-10|] compile_fail
+```rust compile_fail [8-10|]
 enum TypeEnum {
     Id1,
     Id2,

slides/src/variables.md

@@ -40,7 +40,7 @@ fn main() {
 
 ## Interdiction: utilisation sans initialisation
 
-```rust  [2-3|] compile_fail
+```rust compile_fail [2-3|]
 fn main() {
     let x: i32;
     println!("La valeur de x est: {}", x);
@@ -60,7 +60,7 @@ fn main() {
 
 ## Portée: pas ok
 
-```rust [2-5|6|] compile_fail
+```rust compile_fail [2-5|6|]
 fn main() {
     {
         let x = 5; 
@@ -88,7 +88,7 @@ fn main() {
 
 ## Mutabilité/**Immutabilité**
 
-```rust [2|3|] compile_fail
+```rust compile_fail [2|3|]
 fn main() {
     let x = 5; // variable immutable
     x = 6;     // interdit

slides/src/vec.md

@@ -63,7 +63,7 @@ fn main() { // Prob: on veut modifier v[1]
 
 ## Modification d'élément (version 2)
 
-```rust [3] compile_fail
+```rust compile_fail [3]
 fn main() {
     let v = vec![1, 2, 3, 4];
     let mut elem = &v[1]; // que se passe-t-il à votre avis?
@@ -74,7 +74,7 @@ fn main() {
 
 ## Modification d'élément (version 3)
 
-```rust [2,3|6|] compile_fail
+```rust compile_fail [2,3|6|]
 fn main() {
     let v = vec![1, 2, 3, 4];
     let mut elem = &mut v[1]; // que se passe-t-il à votre avis?
@@ -85,7 +85,7 @@ fn main() {
 
 ## Modification d'élément (version 4)
 
-```rust [3-6|7|] compile_fail
+```rust compile_fail [3-6|7|]
 fn main() {
     let mut v = vec![1, 2, 3, 4];
     let mut elem = &mut v[1]; // que se passe-t-il à votre avis?