Coiffer les chaines de leur chapô 🤠

Co-Authored-By: Ronan Demimuid <[email protected]>
bnjbvr · May 23, 2023 · 1535653 · 1535653
1 parent 7a8c17e
commit 1535653
Show file tree

Hide file tree

Showing 4 changed files with 21 additions and 21 deletions.
diff --git a/README.md b/README.md
@@ -33,22 +33,22 @@ 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>;
+        fonction écrire(&soi, clé: Chaîne, valeur: Chaîne);
+        fonction lire(&soi, clé: Chaîne) -> PeutÊtre<&Chaîne>;
     }
 
-    statique mutable DICTIONNAIRE: PeutÊtre<Dico<Chaine, Chaine>> = Rien;
+    statique mutable DICTIONNAIRE: PeutÊtre<Dico<Chaîne, Chaîne>> = Rien;
 
     structure Concrète;
 
     réalisation CléValeur pour Concrète {
-        fonction écrire(&soi, clé: Chaine, valeur: Chaine) {
+        fonction écrire(&soi, clé: Chaîne, valeur: Chaîne) {
             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> {
+        fonction lire(&soi, clé: Chaîne) -> Résultat<PeutÊtre<&Chaîne>, Chaîne> {
             si soit Quelque(dico) = dangereux { DICTIONNAIRE.en_réf() } {
                 Bien(dico.lire(&clé))
             } sinon {

diff --git a/examples/src/main.rs b/examples/src/main.rs
@@ -4,22 +4,22 @@ rouille::rouille! {
     utilisons std::collections::Dictionnaire comme Dico;
 
     convention CléValeur {
-        fonction écrire(&soi, clé: Chaine, valeur: Chaine);
-        fonction lire(&soi, clé: Chaine) -> Résultat<PeutÊtre<&Chaine>, Chaine>;
+        fonction écrire(&soi, clé: Chaîne, valeur: Chaîne);
+        fonction lire(&soi, clé: Chaîne) -> Résultat<PeutÊtre<&Chaîne>, Chaîne>;
     }
 
-    statique mutable DICTIONNAIRE: PeutÊtre<Dico<Chaine, Chaine>> = Rien;
+    statique mutable DICTIONNAIRE: PeutÊtre<Dico<Chaîne, Chaîne>> = Rien;
 
     structure Concrète;
 
     réalisation CléValeur pour Concrète {
-        fonction écrire(&soi, clé: Chaine, valeur: Chaine) {
+        fonction écrire(&soi, clé: Chaîne, valeur: Chaîne) {
             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> {
+        fonction lire(&soi, clé: Chaîne) -> Résultat<PeutÊtre<&Chaîne>, Chaîne> {
             si soit Quelque(dico) = dangereux { DICTIONNAIRE.en_réf() } {
                 Bien(dico.lire(&clé))
             } sinon {
@@ -28,10 +28,10 @@ rouille::rouille! {
         }
     }
 
-    public(cagette) fonction peut_etre(i: u32) -> PeutÊtre<Résultat<u32, Chaine>> {
+    public(cagette) fonction peut_etre(i: u32) -> PeutÊtre<Résultat<u32, Chaîne>> {
         si i % 2 == 1 {
             si i == 42 {
-                Quelque(Arf(Chaine::depuis("merde")))
+                Quelque(Arf(Chaîne::depuis("merde")))
             } sinon {
                 Quelque(Bien(33))
             }

diff --git a/rouille_compilogénèse_proc_macro/src/lib.rs b/rouille_compilogénèse_proc_macro/src/lib.rs
@@ -71,8 +71,8 @@ fn replace_ident(ident: Ident) -> Option<TokenTree> {
         "Identifiant" => "Ident",
         "FluxDeJetons" => "TokenStream",
         "ArbreDeJetons" => "TokenTree",
-        "vers_chaine" => "to_string",
-        "en_tant_que_chaine" => "as_str",
+        "vers_chaîne" => "to_string",
+        "en_tant_que_chaîne" => "as_str",
         "portée" => "span",
         "Tableau" => "Vec",
         "flux" => "stream",

diff --git a/rouille_proc_macro/src/lib.rs b/rouille_proc_macro/src/lib.rs
@@ -2,12 +2,12 @@ rouille_compilogenese::rouille! {
     utilisons macro_procédurale::{Groupe, Identifiant, FluxDeJetons, ArbreDeJetons};
 
     fonction remplacer_identifiant(identifiant: Identifiant) -> PeutÊtre<ArbreDeJetons> {
-        soit identifiant_chaine = identifiant.vers_chaine();
+        soit identifiant_chaîne = identifiant.vers_chaîne();
 
-        soit nouvelle_chaine = selon identifiant_chaine.en_tant_que_chaine() {
+        soit nouvelle_chaîne = selon identifiant_chaîne.en_tant_que_chaîne() {
             "Arf" => "Err",
             "Bien" => "Ok",
-            "Chaine" => "String",
+            "Chaîne" => "String",
             "Dictionnaire" => "HashMap",
             "Défaut" => "Default",
             "Erreur" => "Error",
@@ -72,8 +72,8 @@ rouille_compilogenese::rouille! {
             "Identifiant" => "Ident",
             "FluxDeJetons" => "TokenStream",
             "ArbreDeJetons" => "TokenTree",
-            "vers_chaine" => "to_string",
-            "en_tant_que_chaine" => "as_str",
+            "vers_chaîne" => "to_string",
+            "en_tant_que_chaîne" => "as_str",
             "portée" => "span",
             "Tableau" => "Vec",
             "flux" => "stream",
@@ -83,10 +83,10 @@ rouille_compilogenese::rouille! {
             "Ponctuation" => "Punct",
             "Litéral" => "Literal",
             "macro_procédurale" => "proc_macro",
-            _ => &identifiant_chaine,
+            _ => &identifiant_chaîne,
         };
 
-        soit nouvel_identifiant = Identifiant::nouveau(nouvelle_chaine, identifiant.portée());
+        soit nouvel_identifiant = Identifiant::nouveau(nouvelle_chaîne, identifiant.portée());
         Quelque(ArbreDeJetons::Identifiant(nouvel_identifiant))
     }