v0.2.15

chapters/015-fonctions-methodes-et-clsmethod.md

@@ -66,4 +66,83 @@ Les règles exactes de préférence entre exact match, conversions explicites/co
 
 Objectif : aucune résolution basée sur le type de retour et aucune conversion implicite ambiguë.
 
+## 15.6 `const method` — V1 REQUIS — FIGÉ
+
+Une `method` ordinaire peut modifier l'état accessible via `this`.
+
+Une `const method` reçoit un accès `const` à `this` et peut être appelée depuis un accès mutable ou const.
+
+```text
+class User {
+    const method getName() -> String {
+        return this::name;
+    }
+
+    method setName(String name) -> Void {
+        this::name = name;
+        return Void;
+    }
+}
+```
+
+Usage :
+
+```text
+User a = ...;
+const User b = a;
+
+a::setName("John"); // OK
+a::getName();       // OK
+
+b::getName();       // OK
+b::setName("John"); // ERROR
+```
+
+Une `const method` ne peut pas :
+
+```text
+réassigner un champ via this
+appeler une method non-const via this
+obtenir puis exposer comme mutable un accès disponible uniquement via this const
+```
+
+`const method` ne signifie pas `pure`.
+
+Elle peut notamment, sous réserve des contrats normaux :
+
+```text
+allouer des valeurs locales
+modifier des valeurs locales mutables
+faire de l'I/O
+faire du logging
+lever une Exception déclarée
+modifier un état externe auquel elle possède indépendamment un accès mutable
+```
+
+La garantie porte uniquement sur la mutation via `this` et les accès dérivés de ce `this` const.
+
+## 15.7 Paramètres et retours `const` — V1 REQUIS — FIGÉ EN PRINCIPE
+
+Un paramètre `const` reçoit un accès non mutable :
+
+```text
+func display(const User user) -> Void
+```
+
+Un argument mutable peut être fourni à un paramètre const, car cela réduit les permissions.
+
+Un argument const ne peut pas être fourni à un paramètre mutable lorsqu'il s'agit d'un accès référence, car cela augmenterait les permissions.
+
+Une callable peut retourner un accès const :
+
+```text
+const method getOwner() -> const User {
+    return this::owner;
+}
+```
+
+Une callable ne peut pas convertir un accès dérivé uniquement d'un receiver const en accès mutable lors du retour.
+
+Une valeur indépendante nouvellement créée dans la callable peut naturellement être retournée mutable.
+
 ---