diff --git a/README.md b/README.md
index 77b67d5..0c29339 100644
--- a/README.md
+++ b/README.md
@@ -23,29 +23,32 @@ convenience.
 Here's an example of what can be achieved with Rouille:
 
 ```rust
-utilisons std::collections::Dictionnaire comme Dico;
+rouille::rouille! {
+    utilisons std::collections::Dictionnaire comme Dico;
 
-convention CléValeur {
-    fonction écrire(&soi, clé: Chaine, valeur: Chaine);
-    fonction lire(&soi, clé: Chaine) -> PeutÊtre<&Chaine>;
-}
-
-statique mutable DICTIONNAIRE: PeutÊtre<Dico<Chaine, Chaine>> = Rien;
-
-structure Concrète;
-
-réalisation CléValeur pour Concrète {
-    fonction écrire(&soi, clé: Chaine, valeur: Chaine) {
-        soit dico = dangereux {
-            DICTIONNAIRE.prendre_ou_insérer_avec(Défaut::défaut)
-        };
-        dico.insérer(clé, valeur);
+    convention CléValeur {
+        fonction écrire(&soi, clé: Chaine, valeur: Chaine);
+        fonction lire(&soi, clé: Chaine) -> PeutÊtre<&Chaine>;
     }
-    fonction lire(&soi, clé: Chaine) -> PeutÊtre<&Chaine> {
-        soit dico = dangereux {
-            DICTIONNAIRE.prendre_ou_insérer_avec(Défaut::défaut)
-        };
-        dico.lire(&clé)
+
+    statique mutable DICTIONNAIRE: PeutÊtre<Dico<Chaine, Chaine>> = Rien;
+
+    structure Concrète;
+
+    réalisation CléValeur pour Concrète {
+        fonction écrire(&soi, clé: Chaine, valeur: Chaine) {
+            soit dico = dangereux {
+                DICTIONNAIRE.prendre_ou_insérer_avec(Défaut::défaut)
+            };
+            dico.insérer(clé, valeur);
+        }
+        fonction lire(&soi, clé: Chaine) -> Résultat<PeutÊtre<&Chaine>, Chaine> {
+            si soit Quelque(dico) = dangereux { DICTIONNAIRE.en_réf() } {
+                Bien(dico.lire(&clé))
+            } sinon {
+                Arf("fetchez le dico".vers())
+            }
+        }
     }
 }
 ```
diff --git a/examples/src/main.rs b/examples/src/main.rs
index 1f8aeba..6898cae 100644
--- a/examples/src/main.rs
+++ b/examples/src/main.rs
@@ -5,7 +5,7 @@ rouille::rouille! {
 
     convention CléValeur {
         fonction écrire(&soi, clé: Chaine, valeur: Chaine);
-        fonction lire(&soi, clé: Chaine) -> PeutÊtre<&Chaine>;
+        fonction lire(&soi, clé: Chaine) -> Résultat<PeutÊtre<&Chaine>, Chaine>;
     }
 
     statique mutable DICTIONNAIRE: PeutÊtre<Dico<Chaine, Chaine>> = Rien;
@@ -19,11 +19,12 @@ rouille::rouille! {
             };
             dico.insérer(clé, valeur);
         }
-        fonction lire(&soi, clé: Chaine) -> PeutÊtre<&Chaine> {
-            soit dico = dangereux {
-                DICTIONNAIRE.prendre_ou_insérer_avec(Défaut::défaut)
-            };
-            dico.lire(&clé)
+        fonction lire(&soi, clé: Chaine) -> Résultat<PeutÊtre<&Chaine>, Chaine> {
+            si soit Quelque(dico) = dangereux { DICTIONNAIRE.en_réf() } {
+                Bien(dico.lire(&clé))
+            } sinon {
+                Arf("fetchez le dico".vers())
+            }
         }
     }
 
@@ -49,7 +50,7 @@ rouille::rouille! {
     fonction principale() {
         soit mutable x = 31;
 
-        correspond x {
+        selon x {
             42 => {
                 affiche!("omelette du fromage")
             }
diff --git a/rouille_proc_macro/src/lib.rs b/rouille_proc_macro/src/lib.rs
index 3974a65..67e591f 100644
--- a/rouille_proc_macro/src/lib.rs
+++ b/rouille_proc_macro/src/lib.rs
@@ -4,6 +4,9 @@ fn replace_ident(ident: Ident) -> Option<TokenTree> {
     let ident_str = ident.to_string();
 
     let new_str = match ident_str.as_str() {
+        "vers" => "into",
+        "réf" => "ref",
+        "en_réf" => "as_ref",
         "Arf" => "Err",
         "Bien" => "Ok",
         "Chaine" => "String",
@@ -24,7 +27,7 @@ fn replace_ident(ident: Ident) -> Option<TokenTree> {
         "cagette" => "crate",
         "comme" => "as",
         "constant" => "const",
-        "correspond" => "match",
+        "convention" => "trait",
         "dangereux" => "unsafe",
         "de" => "in",
         "depuis" => "from",
@@ -36,10 +39,9 @@ fn replace_ident(ident: Ident) -> Option<TokenTree> {
         "faux" => "false",
         "fonction" => "fn",
         "génial" => "super",
-        "réalisation" => "impl",
         "insérer" => "insert",
-        "convention" => "trait",
         "lire" => "get",
+        "merde" | "calisse" | "oups" => "panic",
         "module" => "mod",
         "mutable" => "mut",
         "nouveau" => "new",
@@ -50,6 +52,8 @@ fn replace_ident(ident: Ident) -> Option<TokenTree> {
         "public" => "pub",
         "que" => None?,
         "renvoie" => "return",
+        "réalisation" => "impl",
+        "selon" => "match",
         "si" => "if",
         "sinon" => "else",
         "soi" => "self",