v0.2.15

000-README.md

@@ -1,4 +1,4 @@
-# Bible Saselang 0.2.14
+# Bible Saselang 0.2.15
 
 > **Statut : pré-spécification normative de Saselang V1.**
 >
@@ -7,7 +7,7 @@
 >
 > La V2 visera principalement la réécriture/self-hosting de la toolchain V1 en Saselang lui-même. Les extensions majeures de cibles et d'écosystème sont prévues à partir de V3+.
 >
-> **Révision 0.2.14 :** fermeture du socle générique V1 (contraintes, invariance, const generics, récursivité), formalisation de la complétude/layout des types et des imports explicites non séquentiels, stabilisation supplémentaire des conversions numériques (`NaN`, `NumericConversionError`, réduction anti-doublon) et hiérarchie initiale des capabilities par propriétaire.
+> **Révision 0.2.15 :** formalisation de la mutabilité par défaut et de `const` comme restriction d'accès locale, ajout de `const method`, intégration du modèle Unicode encodé (`Utf8Char`/`Utf16Char`/`Utf32Char`, `Utf8String`/`Utf16String`/`Utf32String`) et de l'annexe de conversions Unicode/encodages.
 
 ## Organisation de cette distribution
 

001-SUMMARY.md

@@ -1,4 +1,4 @@
-# Sommaire — Bible Saselang 0.2.14
+# Sommaire — Bible Saselang 0.2.15
 
 ## Chapitres
 
@@ -59,6 +59,7 @@
 ## Annexes
 
 - [Annexe A — Matrice des conversions numériques](annexes/A-numeric-conversions.md)
+- [Annexe B — Conversions Unicode et encodages](annexes/B-unicode-encoding-conversions.md)
 
 ## Vues documentaires
 

003-CHANGELOG.md

@@ -1,4 +1,19 @@
-# Changelog documentaire — 0.2.14
+# Changelog documentaire — 0.2.15
+
+## 0.2.15
+
+- mutabilité ordinaire confirmée par défaut ; aucun `mut` requis pour les variables/objets ordinaires ;
+- `const` défini comme restriction d'accès locale : pas de réaffectation ni mutation via cet accès, sans immutabilité globale ;
+- alias mutable -> alias const autorisé ; augmentation const -> mutable interdite pour les accès référence ;
+- propagation `const` à travers les membres accédés depuis un receiver const ;
+- introduction de `const method`, distincte de la pureté, et règles pour paramètres/retours const ;
+- qualification `const` intégrée au contrat d'override/implémentation ;
+- rejet explicite d'un modèle visible Rust-like basé sur immutabilité par défaut, `mut`, borrow/lifetimes ordinaires ;
+- `String` mutable via API contrôlée ; `const String` bloque les mutations via cet accès ;
+- intégration Core de `Utf8Char`, `Utf16Char`, `Utf32Char`, `Utf8String`, `Utf16String`, `Utf32String` ;
+- `String` sans `[]`; `UtfXString[index]` lit une code unit brute et `OpIndexMut` reste absent ;
+- aucune conversion/transcodage textuel implicite : conversion explicite avant `append`, concaténation ou autre opération ;
+- ajout de l'annexe B pour les conversions Unicode/encodages.
 
 ## 0.2.14
 

MANIFEST.toml

@@ -1,109 +1,81 @@
 format = 1
-version = "0.2.14"
+version = "0.2.15"
 distribution = "delta"
-base_version = "0.2.13"
+base_version = "0.2.14"
 documentation_layout = "multifile"
 
+[[added]]
+path = "annexes/B-unicode-encoding-conversions.md"
+sha256 = "b6baa4f94d70eb82bf8922cc95e8b388c39a7e22d0c38d3b4f277b72f7fc2a45"
+
 [[modified]]
 path = "000-README.md"
-sha256 = "4ca46426ce93e412b82ce1473202763a9b75dca7a9a76e85f6c7f3afa27245b0"
+sha256 = "648bf6155fba691146a724ebaecbeedca73a2d55d5a17539a1b2926e97c9751f"
 
 [[modified]]
 path = "001-SUMMARY.md"
-sha256 = "a15df88415cfc941907ee03d2d851dbeb12a18ad3c2933fede66e263fd4c95af"
+sha256 = "7f1a95bdf99224c983e1d91fda0bce4b74c656aa6067412c8f292a73097e9fb5"
 
 [[modified]]
 path = "003-CHANGELOG.md"
-sha256 = "e7c56000d0f64d9109e398d19bac6219a0435db0f52fb0548e354364d5eebb8a"
+sha256 = "8f3ea4ad3c3d2f41848851f419baf5d7c6f9aa06f27a9ea84ea42be2ae957775"
 
 [[modified]]
-path = "annexes/A-numeric-conversions.md"
+path = "chapters/002-principes-generaux-du-langage.md"
-sha256 = "7e67ab02a99b7ebbb0d5ac0a16bdc89f70fdfdad0620a3927e3f07a13c722743"
+sha256 = "d07d8c85dd2bd4502d10447e7b2f9782f0172038bba681b165d230f18b2360b0"
 
 [[modified]]
-path = "chapters/001-trajectoire-dimplementation.md"
+path = "chapters/006-types-variables-constantes-et-scopes.md"
-sha256 = "9f0205305e77f3474091795e897743c4e2012fc94a04a954509a7a6c3f3f43ed"
+sha256 = "1fa6a92649edec9a1a8393908a87fd297aebe4f9899cbadabd9fe8c8c4560f70"
 
 [[modified]]
-path = "chapters/005-types-primitifs.md"
+path = "chapters/015-fonctions-methodes-et-clsmethod.md"
-sha256 = "c723a1fde76ee90badae1d08deab9e7b8e59da6622979c3f89f3da495efe8157"
+sha256 = "eabe7b33970c42d6c08f31c8de147c6dcce46725b69abe52218686121028191f"
 
 [[modified]]
-path = "chapters/007-types-nominaux-et-fichiers-saseltype.md"
+path = "chapters/016-dispatch-override-et-modificateurs.md"
-sha256 = "1b853fb1160d397565988e3a8dbb9b52b8c5cfbca0c2428948221955728f715c"
+sha256 = "597d31ef050753fca9dd2017c5c3a0847afcfae067ca3ac66a45fd7494b5ba2d"
 
 [[modified]]
-path = "chapters/014-generics.md"
+path = "chapters/021-strings-unicode-et-encodages.md"
-sha256 = "c827e50f5efd51480e0fc250a3e92d75f40eaadc5d47b42078ae16b4c6c5f14a"
+sha256 = "617f15ca05d2676ea4b0db3c6abf023d1c793dc93aa08e7b588c27bf6bb74a42"
 
 [[modified]]
-path = "chapters/024-casts-et-conversions.md"
+path = "chapters/027-memoire-references-et-unsafe.md"
-sha256 = "d625afcee310a5c2eee2342ea96c86cd24f7185a91919849e05641b50ac47b58"
+sha256 = "aaa6d7928a107c5480d39761d5e50b3dd6d87db8402cfbe22302093b39fd913e"
 
 [[modified]]
-path = "chapters/033-imports-et-resolution-des-noms.md"
+path = "chapters/047-concepts-rejetes-ou-deconseilles.md"
-sha256 = "9e392a4d7adf6c3569f50f6664709a64d3398ded98a6f5365eff5175a9f2a8b5"
+sha256 = "4c038901eb53bac11be814e8d56359f7c6814d628a21c17dcd3f16f47fd45320"
-
-[[modified]]
-path = "chapters/040-targets-plateformes-architectures-abi-distributions-et-capabilities.md"
-sha256 = "626fb71b95a930cf44ab3ae41f059a12df369063563bde60cb33e7876e045f3f"
-
-[[modified]]
-path = "chapters/048-inventaire-des-points-v1-encore-ouverts.md"
-sha256 = "a559b1de74ede0e5b5a209d4fe451e00a5a9d9dfcc1357ef07e376780495545c"
-
-[[modified]]
-path = "chapters/049-elements-v1-reserves-mais-non-obligatoires-a-implementer-immediatement.md"
-sha256 = "1995d1fc3229f3df6456548bec38b2e1adbc29958cef7c8397d137283d0ed243"
 
 [[modified]]
 path = "chapters/051-invariants-de-conception.md"
-sha256 = "b02f60468fe292bcfac773a98cf14b865d0fc1936bf353a299d02fec37579a19"
+sha256 = "e27272b1f32546efbc188c3bb9225a128a795b33814648fca2f9e31137d54eab"
 
 [[modified]]
-path = "chapters/052-priorite-de-specification-apres-0-2-9.md"
+path = "examples/002-principes-generaux-du-langage-examples.md"
-sha256 = "b8b47f694ea42489e0e83237cbb8c956a716227428e15d8f14c9237266e332a9"
+sha256 = "ee17304997a099374265aef8b7934507740be3129df7adf0037488d7a536d3e0"
 
 [[modified]]
-path = "examples/001-trajectoire-dimplementation-examples.md"
+path = "examples/006-types-variables-constantes-et-scopes-examples.md"
-sha256 = "b66c40c7bfc9d76fe80e15f90fcef9c3ab8eabcdbec134fb3f660cfc2b79b5f9"
+sha256 = "daff10eb742465242b19436bc30edd797b127ede9ef326cb37bb68cd4495f5b9"
 
 [[modified]]
-path = "examples/005-types-primitifs-examples.md"
+path = "examples/015-fonctions-methodes-et-clsmethod-examples.md"
-sha256 = "9d131cd3874606d92988c2fc9ac24dc04c1349893f2be6678618cf13673a94ab"
+sha256 = "3ea40250b68ef69cc2186c7eb59baa17575b5ca07d3a6f289802cb9a89287140"
 
 [[modified]]
-path = "examples/007-types-nominaux-et-fichiers-saseltype-examples.md"
+path = "examples/016-dispatch-override-et-modificateurs-examples.md"
-sha256 = "a5e4dd8a36a63ea4aba31945379905ed76686b5849bbfb7f7690e5e8c3856ebd"
+sha256 = "5e34730cad71ac15bcdb10389da4116575d4e1876fee29c7c8a050ef46749dfa"
 
 [[modified]]
-path = "examples/014-generics-examples.md"
+path = "examples/021-strings-unicode-et-encodages-examples.md"
-sha256 = "c1912b3657b0633e9d143e069bd75eb079486d1f2de8e6cd67f374aa7edcd78b"
+sha256 = "5351ee93c4a6a15de77c5c6433b0ffdc91763846f0deeeb95838f403324ce623"
 
 [[modified]]
-path = "examples/024-casts-et-conversions-examples.md"
+path = "examples/027-memoire-references-et-unsafe-examples.md"
-sha256 = "5e402ca2584d2272b88a656d335ea8360224de937d75cab3b5c9f83efbf608af"
+sha256 = "700002e9cabd500a9a7fb505deaecec5d23fe31da1feda27df5f5169825e8a52"
 
 [[modified]]
-path = "examples/033-imports-et-resolution-des-noms-examples.md"
+path = "examples/047-concepts-rejetes-ou-deconseilles-examples.md"
-sha256 = "2932904dce7683d2da856a6be78ba09f57ef1dd4d95c3df8c4280685d28c9003"
+sha256 = "8cc0933a6f58a833c57dadeb8683a50c5225dcc461b8aac6824de23a54a9da3f"
-
-[[modified]]
-path = "examples/040-targets-plateformes-architectures-abi-distributions-et-capabilities-examples.md"
-sha256 = "c42e68657c168e6bab2e1d6d4050530f34f649a2be785e66efd64a310e082f3e"
-
-[[modified]]
-path = "examples/048-inventaire-des-points-v1-encore-ouverts-examples.md"
-sha256 = "0fe4bab707d7ec4a01e33dbf3ed65d146fa4b33b495da20f8cbe89b89113e5d3"
-
-[[modified]]
-path = "examples/049-elements-v1-reserves-mais-non-obligatoires-a-implementer-immediatement-examples.md"
-sha256 = "85cb6954c4fc2f5dcb3be207d936a412f1633b81d704ad34c8d63c02cb5b4c5e"
-
-[[modified]]
-path = "examples/051-invariants-de-conception-examples.md"
-sha256 = "bcf646572abee78a42bdb4e2452b2db53ea38c799cd6c131ec108be0bf6b76c2"
-
-[[modified]]
-path = "examples/052-priorite-de-specification-apres-0-2-9-examples.md"
-sha256 = "9990f270f36c071dbd471e6955e40156164b8b75baa073668dc8e5e9c258d935"

annexes/B-unicode-encoding-conversions.md

@@ -0,0 +1,287 @@
+# Annexe B — Matrice des conversions Unicode et encodages
+
+## B.1. Principes normatifs
+
+Cette annexe inventorie les conversions entre les représentations textuelles fondamentales de Saselang et les unités brutes d'encodage.
+
+Elle applique les mêmes principes que la matrice numérique :
+
+```text
+aucune conversion implicite
+aucun mélange de types dans les opérations textuelles
+to... uniquement pour une conversion totale et sûre
+tryFrom... / tryTo... lorsqu'une validation ou une condition peut échouer
+aucun alias redondant
+conversion explicite d'abord, opération ensuite
+```
+
+## B.2. Types concernés
+
+### B.2.1. Niveau Unicode sémantique
+
+```text
+char
+    exactement un Unicode scalar
+
+String
+    séquence Unicode sémantique de char
+    encodage physique non observable
+```
+
+### B.2.2. Niveau Unicode encodé
+
+```text
+Utf8Char
+    encodage UTF-8 valide d'exactement un Unicode scalar
+    1 à 4 uint8
+
+Utf16Char
+    encodage UTF-16 valide d'exactement un Unicode scalar
+    1 à 2 uint16
+
+Utf32Char
+    encodage UTF-32 valide d'exactement un Unicode scalar
+    exactement 1 uint32
+```
+
+```text
+Utf8String
+    séquence UTF-8 valide
+
+Utf16String
+    séquence UTF-16 valide
+
+Utf32String
+    séquence UTF-32 valide
+```
+
+### B.2.3. Code units brutes
+
+```text
+UTF-8  code unit = uint8
+UTF-16 code unit = uint16
+UTF-32 code unit = uint32
+```
+
+Aucun type `UtfXCodeUnit` distinct n'est défini sans besoin sémantique supplémentaire.
+
+## B.3. Invariants
+
+Toute valeur `UtfXChar` et `UtfXString` est valide pour son encodage.
+
+Ces types peuvent être mutables via leurs méthodes contrôlées, mais aucune API ne peut laisser leur valeur dans un état d'encodage invalide.
+
+Une mutation brute de code unit n'est donc pas exposée.
+
+Un accès `const` interdit les mutations via cet accès selon les règles générales du langage.
+
+## B.4. `char` <-> `UtfXChar`
+
+| Source | Destination | Opération |
+|---|---|---|
+| `char` | `Utf8Char` | `toUtf8Char()` |
+| `char` | `Utf16Char` | `toUtf16Char()` |
+| `char` | `Utf32Char` | `toUtf32Char()` |
+| `Utf8Char` | `char` | `toChar()` |
+| `Utf16Char` | `char` | `toChar()` |
+| `Utf32Char` | `char` | `toChar()` |
+
+Toutes ces conversions sont totales.
+
+## B.5. `UtfXChar` <-> `UtfYChar`
+
+| Source | Destination | Opération |
+|---|---|---|
+| `Utf8Char` | `Utf16Char` | `toUtf16Char()` |
+| `Utf8Char` | `Utf32Char` | `toUtf32Char()` |
+| `Utf16Char` | `Utf8Char` | `toUtf8Char()` |
+| `Utf16Char` | `Utf32Char` | `toUtf32Char()` |
+| `Utf32Char` | `Utf8Char` | `toUtf8Char()` |
+| `Utf32Char` | `Utf16Char` | `toUtf16Char()` |
+
+Ces transcodages sont totaux.
+
+## B.6. Code unit brute -> `UtfXChar`
+
+UTF-8 :
+
+```text
+Utf8Char::tryFrom(uint8)
+Utf8Char::tryFrom(StaticArray<uint8, N>)
+```
+
+`N` utile : 1 à 4. Le contenu doit représenter exactement un scalar UTF-8 valide.
+
+UTF-16 :
+
+```text
+Utf16Char::tryFrom(uint16)
+Utf16Char::tryFrom(StaticArray<uint16, 2>)
+```
+
+Un surrogate isolé est invalide.
+
+UTF-32 :
+
+```text
+Utf32Char::tryFrom(uint32)
+```
+
+La valeur doit être <= `0x10FFFF` et hors de la plage surrogate.
+
+Le nom de travail de l'erreur est :
+
+```text
+UnicodeEncodingError extends ResultError
+```
+
+## B.7. `UtfXChar` -> code unit brute
+
+| Source | Destination | Opération | Raison |
+|---|---|---|---|
+| `Utf8Char` | `uint8` | `tryToUint8()` | 1 à 4 unités possibles |
+| `Utf16Char` | `uint16` | `tryToUint16()` | 1 ou 2 unités possibles |
+| `Utf32Char` | `uint32` | `toUint32()` | exactement 1 unité |
+
+Les séquences complètes de code units sont accessibles via `codeUnits()`. Le type concret de vue retourné sera fixé avec les collections/slices.
+
+## B.8. `String` <-> `UtfXString`
+
+| Source | Destination | Opération |
+|---|---|---|
+| `String` | `Utf8String` | `toUtf8String()` |
+| `String` | `Utf16String` | `toUtf16String()` |
+| `String` | `Utf32String` | `toUtf32String()` |
+| `Utf8String` | `String` | `toString()` |
+| `Utf16String` | `String` | `toString()` |
+| `Utf32String` | `String` | `toString()` |
+
+Toutes ces conversions sont totales.
+
+## B.9. `UtfXString` <-> `UtfYString`
+
+| Source | Destination | Opération |
+|---|---|---|
+| `Utf8String` | `Utf16String` | `toUtf16String()` |
+| `Utf8String` | `Utf32String` | `toUtf32String()` |
+| `Utf16String` | `Utf8String` | `toUtf8String()` |
+| `Utf16String` | `Utf32String` | `toUtf32String()` |
+| `Utf32String` | `Utf8String` | `toUtf8String()` |
+| `Utf32String` | `Utf16String` | `toUtf16String()` |
+
+Tous ces transcodages sont explicites et totaux.
+
+## B.10. Données brutes -> `UtfXString`
+
+Conceptuellement :
+
+```text
+Utf8String::tryFrom(Array<uint8>)
+Utf16String::tryFrom(Array<uint16>)
+Utf32String::tryFrom(Array<uint32>)
+```
+
+Le type exact accepté pourra inclure des slices/vues lors de leur définition.
+
+La construction valide l'intégralité de la séquence. Une valeur `UtfXString` invalide ne peut jamais être produite.
+
+## B.11. Indexation et accès nommés
+
+```text
+String
+    pas de OpIndex
+    scalarAt(uint64) -> char
+```
+
+```text
+Utf8String[index]  -> uint8
+Utf16String[index] -> uint16
+Utf32String[index] -> uint32
+```
+
+Ces indexations sont read-only.
+
+Accès par scalar ordinal :
+
+```text
+Utf8String::encodedCharAt(uint64)  -> Utf8Char
+Utf16String::encodedCharAt(uint64) -> Utf16Char
+Utf32String::encodedCharAt(uint64) -> Utf32Char
+```
+
+et :
+
+```text
+Utf8String::scalarAt(uint64)  -> char
+Utf16String::scalarAt(uint64) -> char
+Utf32String::scalarAt(uint64) -> char
+```
+
+## B.12. Itérations/vues explicites
+
+```text
+codeUnits()
+encodedChars()
+scalars()
+```
+
+Les strings encodées n'imposent pas un `Iterable<T>` direct unique, car ces trois unités sont légitimes et différentes.
+
+`String`, dont l'unité sémantique est non ambiguë, implémente `Iterable<char>`.
+
+## B.13. Interaction `UtfXString` / `UtfXChar`
+
+Une `UtfXString` accepte directement uniquement les caractères et strings du même encodage dans ses opérations typées.
+
+```text
+Utf8String text = ...;
+Utf8Char c = ...;
+Utf16Char d = ...;
+
+text::append(c);                // OK
+text::append(d);                // ERROR
+text::append(d::toUtf8Char());  // OK
+```
+
+Même règle pour concaténation, insertion, remplacement et autres opérations.
+
+Aucun transcodage n'est déclenché implicitement par la méthode appelée.
+
+## B.14. Mutabilité et `const`
+
+`String` et `UtfXString` peuvent exposer des méthodes mutantes.
+
+```text
+String text = "abc";
+text::append("def");
+```
+
+`text` est modifiée selon le contrat de `append`.
+
+Les `UtfXString` maintiennent leur invariant d'encodage lors de toute mutation contrôlée.
+
+```text
+Utf8String text = ...;
+Utf8Char c = ...;
+
+text::append(c);      // OK
+text[index] = 0xFF;   // ERROR
+```
+
+Avec :
+
+```text
+const Utf8String text = ...;
+```
+
+les opérations mutantes sont interdites via `text`, mais un autre alias mutable vers le même objet peut continuer à le modifier.
+
+## B.15. Points encore à fermer
+
+1. type exact des vues `codeUnits()`, `encodedChars()` et `scalars()` ;
+2. modèle des slices/substrings et frontières de code units ;
+3. nom exact de l'API de décodage depuis un offset de code unit ;
+4. API précise de concaténation et ses opérateurs ;
+5. builders/buffers et leurs relations avec les strings valides ;
+6. codes définitifs de `UnicodeEncodingError` ;
+7. localisation Core/SDK des opérations Unicode avancées : graphemes, normalisation, case folding, collation.

chapters/002-principes-generaux-du-langage.md

@@ -193,4 +193,19 @@ Les diagnostics tels que `unused local`, `unused parameter`, `unused private ite
 
 Le formatter ne doit pas devenir un linter de nommage ni modifier la sémantique du programme.
 
+## 2.8 Mutabilité par défaut — V1 REQUIS — FIGÉ
+
+Saselang est mutable par défaut lorsque le type expose des opérations mutantes valides.
+
+Le langage n'impose pas de mot-clé `mut` pour le cas ordinaire et n'adopte pas l'immutabilité par défaut.
+
+```text
+String text = "abc";
+text::append("def"); // OK si append est une méthode mutante de String
+```
+
+`const` est la restriction explicite qui retire les droits de mutation depuis un accès donné.
+
+Cette règle vise une ergonomie syntaxique familière, proche des langages objets classiques, sans introduire un modèle d'ownership/borrowing visible de type Rust.
+
 ---

chapters/006-types-variables-constantes-et-scopes.md

@@ -49,4 +49,100 @@ foo(a(), b(), c())
 
 évalue `a()`, puis `b()`, puis `c()`.
 
+## 6.6 Mutabilité et `const` — V1 REQUIS — FIGÉ
+
+La mutabilité est le comportement normal de Saselang.
+
+```text
+Type value = ...;
+```
+
+peut être réassigné et peut servir à appeler les opérations mutantes que son type expose, sous réserve des autres règles du langage.
+
+```text
+const Type value = ...;
+```
+
+crée un accès `const`.
+
+Un accès `const` :
+
+```text
+interdit la réaffectation du binding
+interdit toute mutation obtenue uniquement à travers ce binding
+n'impose aucune immutabilité globale à l'objet éventuellement référencé
+n'affecte pas les autres alias mutables légitimes
+```
+
+Exemple classe/référence :
+
+```text
+User a = ...;
+const User b = a;
+
+a::setName("John"); // OK
+b::setName("John"); // ERROR
+b::getName();       // OK et observe la modification faite via a
+```
+
+`const` qualifie donc un accès, pas l'identité globale ni le stockage physique de l'objet.
+
+## 6.7 Propagation d'un accès `const` — V1 REQUIS — FIGÉ
+
+Un accès obtenu uniquement à travers un receiver `const` reste `const`.
+
+```text
+const User user = ...;
+
+user::address::getCity();         // OK si const method
+user::address::setCity("Paris");  // ERROR
+```
+
+Le compilateur ne permet pas d'augmenter les droits d'un accès référence :
+
+```text
+const User source = ...;
+User mutable = source; // ERROR
+```
+
+La réduction des droits est autorisée :
+
+```text
+User source = ...;
+const User readonly = source; // OK
+```
+
+Pour une valeur réellement copiée by-value, une copie indépendante peut devenir une nouvelle variable mutable :
+
+```text
+const int32 a = 10;
+int32 b = a; // OK
+b = 20;      // OK
+```
+
+La même règle s'applique aux structs lorsqu'une copie by-value indépendante est effectuée selon leur contrat de copie.
+
+## 6.8 Champs `const` — V1 REQUIS — FIGÉ EN PRINCIPE
+
+Un champ peut être déclaré `const`.
+
+```text
+class Document {
+    const User owner;
+}
+```
+
+Le champ reçoit sa valeur conformément aux règles de construction et d'assignation unique, puis ne peut plus être réassigné via ce champ.
+
+L'accès obtenu via ce champ est `const`.
+
+```text
+this::owner = other;        // ERROR après initialisation
+this::owner::setName(...);  // ERROR via cet accès
+```
+
+Un autre alias mutable indépendant vers le même objet peut toujours le modifier.
+
+`const` n'est donc ni un mécanisme d'ownership, ni une garantie d'immutabilité globale, ni un verrou runtime.
+
 ---

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.
+
 ---

chapters/016-dispatch-override-et-modificateurs.md

@@ -10,6 +10,7 @@ visibility
 -> linkage / ABI
 -> type / dispatch modifiers
 -> override
+-> access qualifier
 -> declaration kind
 ```
 
@@ -31,8 +32,9 @@ public open class Service
 public abstract class Base
 public unsafe extern "C" union NativeValue
 protected open method calculate(...)
+protected const method inspect(...)
 protected override method calculate(...)
-protected final override method calculate(...)
+protected final override const method inspect(...)
 ```
 
 Les ordres alternatifs sont des erreurs syntaxiques même s'ils seraient théoriquement compréhensibles.
@@ -83,4 +85,20 @@ Une exposition plus large nécessite un wrapper explicite.
 
 Les détails d'accès via une autre instance d'une classe dérivée doivent être figés dans les règles finales de résolution membre.
 
+## 16.5 Qualification `const` dans les contrats — V1 REQUIS — FIGÉ
+
+La qualification `const` d'une méthode fait partie de son contrat de mutation.
+
+Une implémentation ou un override doit conserver exactement cette qualification en V1.
+
+```text
+const method
+    doit être implémentée/overridée par const method
+
+method
+    doit être implémentée/overridée par method
+```
+
+Saselang n'effectue pas de changement implicite de mutabilité dans une hiérarchie de contrats.
+
 ---

chapters/021-strings-unicode-et-encodages.md

@@ -2,39 +2,22 @@
 
 ## 21.1 `String` — V1 REQUIS — FIGÉ EN PRINCIPE
 
-`String` est le type ordinaire de texte Unicode.
+`String` est le type ordinaire de texte Unicode au niveau sémantique.
 
-La représentation interne peut varier suivant le backend/target, mais la sémantique observable doit rester identique.
+Sa valeur observable est une séquence de Unicode scalar values.
 
-## 21.2 Encodages explicites — V1 REQUIS — DIRECTION FIGÉE
+La représentation physique interne peut varier suivant le backend/target, sans devenir observable via l'API sémantique de `String`.
 
-Les encodages explicites appartiennent au SDK, pas au langage :
+`String` est mutable par défaut lorsque son API expose des opérations mutantes contrôlées.
 
 ```text
-Utf8String
+String text = "abc";
-Utf16String
+text::append("def"); // OK
-Utf32String
-AsciiString éventuel
-Bytes
 ```
 
-Les conversions avec `String` doivent être explicites et définies.
+Un accès `const String` interdit les mutations via cet accès selon les règles générales de `const`.
 
-## 21.3 Indexation String — V1 REQUIS — À FINALISER
+## 21.2 `char` — V1 REQUIS — FIGÉ
-
-Il faut décider avant V1 ce que signifie l'accès au texte :
-
-```text
-byte
-code unit
-Unicode scalar
-code point
-grapheme cluster
-```
-
-Ne pas déclarer implicitement `String : OpIndex<uint64,char>` avant cette décision.
-
-## 21.4 `char` — V1 REQUIS — FIGÉ
 
 `char` représente exactement un Unicode scalar value, et non un octet, une unité UTF-8/UTF-16 ou un grapheme utilisateur complet.
 
@@ -49,13 +32,251 @@ Exemples valides :
 '\u{1F600}'
 ```
 
-Après traitement des escapes, un littéral `char` doit contenir exactement un scalar. `''`, `'ab'` ou une séquence produisant plusieurs scalars sont invalides.
+Après traitement des escapes, un littéral `char` doit contenir exactement un scalar.
 
-Saselang n'effectue aucune normalisation Unicode implicite des littéraux ; NFC/NFD et autres transformations relèvent d'opérations explicites de bibliothèque.
+Saselang n'effectue aucune normalisation Unicode implicite.
 
-## 21.5 Familles de littéraux texte — V1 REQUIS / RÉSERVÉ
+## 21.3 Types encodés Core — V1 REQUIS — DIRECTION FIGÉE
 
-Les familles suivantes sont reconnues ou réservées parce qu'elles représentent des sémantiques distinctes et non des alias gratuits :
+Le Core fournit les types encodés explicites :
+
+```text
+Utf8Char
+Utf16Char
+Utf32Char
+
+Utf8String
+Utf16String
+Utf32String
+```
+
+Ils ne sont ni des alias ni des sous-classes de `String`/`char`.
+
+Ils expriment explicitement l'encodage utilisé.
+
+```text
+Utf8Char
+    exactement un Unicode scalar encodé en UTF-8
+    1 à 4 uint8
+
+Utf16Char
+    exactement un Unicode scalar encodé en UTF-16
+    1 à 2 uint16
+
+Utf32Char
+    exactement un Unicode scalar encodé en UTF-32
+    1 uint32
+```
+
+```text
+Utf8String
+    séquence UTF-8 valide
+
+Utf16String
+    séquence UTF-16 valide
+
+Utf32String
+    séquence UTF-32 valide
+```
+
+Toute valeur de ces types maintient son invariant d'encodage.
+
+Les code units brutes restent :
+
+```text
+UTF-8  -> uint8
+UTF-16 -> uint16
+UTF-32 -> uint32
+```
+
+Aucun `Utf8CodeUnit` / `Utf16CodeUnit` / `Utf32CodeUnit` distinct n'est introduit tant qu'un besoin sémantique réel n'est pas démontré.
+
+## 21.4 Conversions Unicode — V1 REQUIS — FIGÉ EN PRINCIPE
+
+Aucun transcodage implicite n'existe.
+
+Les conversions totales utilisent `to...`.
+
+Les constructions ou réductions pouvant échouer utilisent `tryFrom...` / `tryTo...`.
+
+Exemples :
+
+```text
+char::toUtf8Char()
+Utf8Char::toChar()
+Utf8Char::toUtf16Char()
+
+Utf8Char::tryFrom(uint8)
+Utf16Char::tryFrom(uint16)
+Utf32Char::tryFrom(uint32)
+
+Utf8Char::tryToUint8()
+Utf16Char::tryToUint16()
+Utf32Char::toUint32()
+```
+
+La matrice normative détaillée est définie dans `annexes/B-unicode-encoding-conversions.md`.
+
+## 21.5 Aucun mélange implicite de types — V1 REQUIS — FIGÉ
+
+Une API textuelle n'effectue jamais un transcodage implicite de son argument.
+
+```text
+Utf8String text = ...;
+Utf16Char value = ...;
+
+text::append(value);                // ERROR
+text::append(value::toUtf8Char());  // OK
+```
+
+Même règle pour concaténation, insertion, remplacement, recherche typée et construction.
+
+Les conversions sont effectuées explicitement avant l'opération métier.
+
+## 21.6 Indexation — V1 REQUIS — FIGÉ
+
+`String` n'implémente pas `OpIndex`.
+
+```text
+String text = ...;
+text[5]; // ERROR
+```
+
+Son unité logique est explicitement nommée :
+
+```text
+text::scalarAt(index) -> char
+text::scalarCount() -> uint64
+```
+
+Les strings encodées peuvent exposer `[]` en lecture pour leurs code units physiques :
+
+```text
+Utf8String[index]  -> uint8
+Utf16String[index] -> uint16
+Utf32String[index] -> uint32
+```
+
+Elles n'exposent pas `OpIndexMut`, afin qu'une écriture brute ne puisse pas casser l'invariant d'encodage.
+
+## 21.7 Accès scalar et caractère encodé — V1 REQUIS — FIGÉ EN PRINCIPE
+
+Pour un `UtfXString` :
+
+```text
+encodedCharAt(scalarIndex)
+    retourne le UtfXChar correspondant au scalar ordinal demandé
+
+scalarAt(scalarIndex)
+    retourne le char correspondant
+```
+
+Exemples :
+
+```text
+Utf8String::encodedCharAt(uint64)  -> Utf8Char
+Utf16String::encodedCharAt(uint64) -> Utf16Char
+Utf32String::encodedCharAt(uint64) -> Utf32Char
+
+Utf8String::scalarAt(uint64)  -> char
+Utf16String::scalarAt(uint64) -> char
+Utf32String::scalarAt(uint64) -> char
+```
+
+Un index de code unit et un ordinal de scalar sont des concepts distincts.
+
+Une API de décodage depuis un offset de code unit peut exister explicitement. En UTF-8/UTF-16, elle est faillible lorsqu'un offset peut pointer au milieu d'une séquence encodée.
+
+Le nom exact de cette API reste à stabiliser avec les vues/slices.
+
+## 21.8 Comptage — V1 REQUIS — FIGÉ
+
+`String` expose :
+
+```text
+scalarCount()
+```
+
+Les strings encodées distinguent :
+
+```text
+codeUnitCount()
+scalarCount()
+```
+
+Ces deux propriétés restent distinctes même lorsqu'elles coïncident systématiquement dans UTF-32, car elles décrivent deux unités sémantiques différentes.
+
+## 21.9 Itération — V1 REQUIS — FIGÉ EN PRINCIPE
+
+`String` possède une unité sémantique non ambiguë :
+
+```text
+String implements Iterable<char>
+```
+
+Pour `Utf8String`, `Utf16String` et `Utf32String`, plusieurs parcours utiles existent :
+
+```text
+code units
+encoded chars
+Unicode scalars
+```
+
+Aucun `Iterable<T>` direct unique n'est imposé aux strings encodées en V1.
+
+Les parcours sont explicites :
+
+```text
+codeUnits()
+encodedChars()
+scalars()
+```
+
+Le type concret de vue/itérateur retourné sera fixé avec les collections et slices.
+
+## 21.10 Mutation contrôlée — V1 REQUIS — FIGÉ
+
+`String` et `UtfXString` ne sont pas intrinsèquement immutables.
+
+Ils peuvent exposer des méthodes mutantes contrôlées.
+
+```text
+String text = "abc";
+text::append("def");
+```
+
+Après l'appel, `text` contient la valeur modifiée selon le contrat de `append`.
+
+Pour les strings encodées, toute méthode mutante doit préserver l'invariant d'encodage.
+
+```text
+Utf8String text = ...;
+Utf8Char value = ...;
+
+text::append(value); // OK
+```
+
+Une mutation brute de code unit reste interdite :
+
+```text
+text[index] = 0xFF; // ERROR
+```
+
+Un accès `const` désactive les opérations mutantes via cet accès, sans rendre globalement immutable l'objet partagé.
+
+## 21.11 Comparaison et normalisation — V1 REQUIS — FIGÉ EN PRINCIPE
+
+Aucune normalisation Unicode, case folding ou collation linguistique n'est implicite.
+
+Deux `String` sont égales selon leur séquence sémantique exacte de Unicode scalars.
+
+Des textes visuellement équivalents mais composés de séquences différentes peuvent donc être différents.
+
+Les normalisations NFC/NFD, case folding, grapheme segmentation et collations localisées relèvent d'API explicites Core/SDK à détailler.
+
+## 21.12 Familles de littéraux texte — V1 REQUIS / RÉSERVÉ
+
+Les familles suivantes sont reconnues ou réservées parce qu'elles représentent des sémantiques distinctes :
 
 ```text
 "..."                 String normale, escapes actifs
@@ -75,96 +296,49 @@ cr"..."               chaîne C brute, réservé
 t"..."                template structuré, réservé
 ```
 
-V1 doit au minimum couvrir les formes normales, multilignes, raw et interpolées. Les formes bytes, encodages explicites, C string, template et certaines combinaisons peuvent être implémentées en V2 mais leur espace lexical est réservé dès V1.
+V1 doit au minimum couvrir les formes normales, multilignes, raw et interpolées.
 
-Les préfixes de littéraux ne sont pas nécessairement des mots-clés globaux : ils sont reconnus comme préfixes lorsqu'ils sont immédiatement contigus au délimiteur correspondant.
+Le délimiteur interne de l'interpolation reste à finaliser entre les formes déjà inventoriées.
 
-Les combinaisons de préfixes ne sont pas arbitraires. Une matrice normative ultérieure doit classer chaque combinaison comme `supported`, `reserved` ou `forbidden/meaningless`, et retenir une seule orthographe canonique par combinaison. Des doublons tels que `ir` et `ri` pour une même sémantique ne coexistent pas.
+## 21.13 Chaînes multilignes — V1 REQUIS — FIGÉ
 
-La forme interpolée `i"..."` est réservée, mais le délimiteur interne de l'expression reste **V1 REQUIS — À FINALISER** entre :
+Les triples quotes fournissent la forme multiligne.
-
-```text
-i"Hello {name}"
-i"Hello ${name}"
-```
-
-Une seule de ces deux formes sera retenue comme syntaxe canonique. Une `String` non préfixée n'interprète jamais ces séquences comme interpolation.
-
-## 21.6 Chaînes multilignes — V1 REQUIS — FIGÉ
-
-Les triples quotes fournissent la forme multiligne :
-
-```text
-"""
-    first
-    second
-    """
-```
 
 Le délimiteur de fermeture détermine l'indentation structurelle à retirer de chaque ligne. Une indentation supplémentaire volontaire dans le contenu est conservée.
 
-Lorsque `"""` d'ouverture est immédiatement suivi d'un retour à la ligne, ce premier retour structurel n'appartient pas à la valeur. Lorsque le délimiteur de fermeture se trouve seul après l'indentation structurelle d'une nouvelle ligne, le dernier retour structurel est également supprimé.
+Lorsque le délimiteur d'ouverture multiligne est immédiatement suivi d'un retour à la ligne, ce premier retour structurel n'appartient pas à la valeur. Lorsque le délimiteur de fermeture se trouve seul après l'indentation structurelle d'une nouvelle ligne, le dernier retour structurel est également supprimé.
-
-La même règle de lignes et d'indentation s'applique aux variantes normales, raw et interpolées. Le caractère raw ou interpolé modifie le traitement du contenu, pas la structure multiligne.
 
 Le formatter peut réindenter la structure source uniquement en préservant exactement la valeur sémantique du littéral.
 
-## 21.7 Raw strings et délimiteurs — V1 REQUIS — FIGÉ
+## 21.14 Raw strings et escapes — V1 REQUIS — FIGÉ
 
-La forme raw utilise un préfixe `r` contigu et peut employer zéro ou plusieurs `#` comme partie du délimiteur :
+Les raw strings utilisent `r` contigu et peuvent employer zéro ou plusieurs `#` dans leur délimiteur.
+
+Aucun escape n'est interprété dans le contenu raw.
+
+Dans les `String` normales et les `char`, l'ensemble canonique reste :
 
 ```text
-r"simple"
+\\
-r#"He said "hello"."#
+\"
-r##"contains "# inside"##
+\'
+\n
+\r
+\t
+\0
+\u{...}
 ```
 
-La fermeture reprend exactement le même nombre de `#` que l'ouverture. Aucun escape n'est interprété dans le contenu raw.
+`\u{...}` contient de 1 à 6 chiffres hexadécimaux, n'accepte pas `_`, doit être inférieur ou égal à `0x10FFFF` et ne peut pas désigner la plage surrogate UTF-16.
 
-La même mécanique est disponible pour les triples quotes :
+`\xNN` reste réservé aux littéraux orientés octets.
 
-```text
+## 21.15 Source Unicode et représentation — V1 REQUIS — FIGÉ EN PRINCIPE
-r"""..."""
-r#"""..."""#
-```
 
-Les `#` appartiennent au délimiteur lexical et ne sont pas des escapes. Les variantes combinées réservées telles que `ir`, `br` ou `cr` suivent le même principe lorsqu'elles seront activées.
+Le fichier source UTF-8 peut contenir directement des scalars Unicode valides dans `String`, `char`, commentaires et Saseldoc.
 
-Une borne d'implémentation raisonnable au nombre de `#` peut être imposée, à condition d'être documentée et diagnostiquée explicitement ; cette borne n'est pas encore normative.
+Une séquence UTF-8 invalide est une erreur de source.
 
-`raw` est une propriété lexicale et ne change pas à elle seule le type résultat.
+La représentation physique interne de `String` reste indépendante de cette syntaxe source et peut varier suivant backend/target.
-
-## 21.8 Escapes normaux — V1 REQUIS — FIGÉ
-
-Dans les `String` normales et les `char`, l'ensemble canonique est :
-
-```text
-\\      backslash
-\"      double quote
-\'      single quote
-\n      newline
-\r      carriage return
-\t      horizontal tab
-\0      NUL
-\u{...} Unicode scalar
-```
-
-`\u{...}` contient de 1 à 6 chiffres hexadécimaux, n'accepte pas `_`, doit être inférieur ou égal à `0x10FFFF` et ne peut pas désigner la plage surrogate UTF-16 `0xD800..0xDFFF`.
-
-Saselang n'introduit pas les alias historiques redondants `\uXXXX`, `\UXXXXXXXX`, les escapes octaux ou les control aliases C rares lorsque `\u{...}` couvre déjà leur besoin.
-
-`\xNN` est réservé aux littéraux orientés octets, notamment `b"..."`, où il représente exactement un octet avec exactement deux chiffres hexadécimaux :
-
-```text
-b"\x00\x7f\x80\xff"
-```
-
-`\xNN` est interdit dans une `String` Unicode normale et dans `char`.
-
-## 21.9 Unicode et représentation — V1 REQUIS — FIGÉ EN PRINCIPE
-
-Le fichier source UTF-8 peut contenir directement des scalars Unicode valides dans `String`, `char`, commentaires et Saseldoc. Une séquence UTF-8 invalide est une erreur de source ; le compilateur ne la répare pas silencieusement.
-
-La représentation physique interne de `String` reste indépendante de cette syntaxe source et peut varier selon backend/target conformément à la section 21.1.
 
 ---

chapters/027-memoire-references-et-unsafe.md

@@ -76,4 +76,21 @@ Les noms des types (`Ptr<T>`, `PtrMut<T>` ou autre) restent à figer.
 
 Le modèle allocator doit être défini avec le modèle mémoire avant finalisation du runtime V1.
 
+## 27.6 Mutabilité visible et `const` — V1 REQUIS — FIGÉ EN PRINCIPE
+
+Le modèle mémoire V1 ne doit pas imposer au code ordinaire :
+
+```text
+mot-clé mut pour obtenir la mutabilité normale
+borrow checker visible dans la syntaxe
+lifetimes utilisateur omniprésents
+ownership annotations pour les usages ordinaires
+```
+
+La mutabilité normale est implicite.
+
+`const` réduit les droits de l'accès qui le porte sans rendre globalement immutable l'objet et sans invalider les autres alias mutables légitimes.
+
+Les analyses internes de move, escape, aliasing ou lifetime restent des libertés d'implémentation tant qu'elles ne changent pas cette sémantique visible.
+
 ---

chapters/047-concepts-rejetes-ou-deconseilles.md

@@ -21,6 +21,9 @@ match guards `when` / `if`
 loop/until/repeat/unless comme synonymes de structures existantes
 magic getters/setters
 mandatory native GC
+immutability by default for ordinary variables/objects
+mandatory `mut` qualifier for ordinary mutation
+Rust-style user-visible borrow/lifetime syntax as the default programming model
 ```
 
 ## 47.2 À éviter sauf besoin démontré

chapters/051-invariants-de-conception.md

@@ -23,5 +23,9 @@ Les futures décisions doivent respecter les invariants suivants :
 19. **Un cycle n'est interdit que par la règle du graphe concerné : héritage et layout by-value doivent être acycliques ; références de classes, imports et appels peuvent être cycliques.**
 20. **Une fonctionnalité n'est réservée que lorsqu'un besoin réel est identifié ; pas de réservation spéculative « au cas où ».**
 21. **Une opération Core combinée n'existe pas lorsqu'une composition d'opérations existantes exprime strictement la même sémantique.**
+22. **La mutabilité est le défaut ; `const` retire explicitement les droits de mutation depuis l'accès concerné.**
+23. **`const` ne crée pas d'immutabilité globale et n'invalide pas les autres alias mutables légitimes.**
+24. **Saselang ne requiert pas de `mut`, borrow syntax ou lifetimes utilisateur pour le code mutable ordinaire.**
+25. **Les conversions et opérations textuelles ne transcendent jamais implicitement les encodages : conversion explicite d'abord, opération ensuite.**
 
 ---

examples/002-principes-generaux-du-langage-examples.md

@@ -1,8 +1,8 @@
 # Exemples / DO-DON'T — Chapitre 2 — Principes généraux du langage
 
-> Document compagnon non normatif tant qu'une règle n'est pas explicitement référencée comme normative par le chapitre.
+> Document compagnon. Les exemples illustrent les règles du chapitre ; la formulation normative reste dans le chapitre lui-même.
 
-## Exemples actuellement présents dans le chapitre
+## Exemples extraits du chapitre
 
 ### Exemple 1
 
@@ -111,6 +111,13 @@ Map<String,List<int32>>
 }
 ```
 
+### Exemple 12
+
+```text
+String text = "abc";
+text::append("def"); // OK si append est une méthode mutante de String
+```
+
 ## DO / DON'T / WHY / compiler error / edge cases
 
-La couverture structurée de cette section sera enrichie au fur et à mesure de la fermeture des règles du chapitre. La migration `0.2.12` conserve volontairement les exemples historiques dans le chapitre afin de ne perdre aucun contexte normatif.
+À consolider progressivement avant la baseline publique V3 et à transformer, lorsque pertinent, en tests de conformité de la toolchain.

examples/006-types-variables-constantes-et-scopes-examples.md

@@ -1,8 +1,8 @@
 # Exemples / DO-DON'T — Chapitre 6 — Types, variables, constantes et scopes
 
-> Document compagnon non normatif tant qu'une règle n'est pas explicitement référencée comme normative par le chapitre.
+> Document compagnon. Les exemples illustrent les règles du chapitre ; la formulation normative reste dans le chapitre lui-même.
 
-## Exemples actuellement présents dans le chapitre
+## Exemples extraits du chapitre
 
 ### Exemple 1
 
@@ -21,6 +21,84 @@
 foo(a(), b(), c())
 ```
 
+### Exemple 3
+
+```text
+Type value = ...;
+```
+
+### Exemple 4
+
+```text
+const Type value = ...;
+```
+
+### Exemple 5
+
+```text
+interdit la réaffectation du binding
+interdit toute mutation obtenue uniquement à travers ce binding
+n'impose aucune immutabilité globale à l'objet éventuellement référencé
+n'affecte pas les autres alias mutables légitimes
+```
+
+### Exemple 6
+
+```text
+User a = ...;
+const User b = a;
+
+a::setName("John"); // OK
+b::setName("John"); // ERROR
+b::getName();       // OK et observe la modification faite via a
+```
+
+### Exemple 7
+
+```text
+const User user = ...;
+
+user::address::getCity();         // OK si const method
+user::address::setCity("Paris");  // ERROR
+```
+
+### Exemple 8
+
+```text
+const User source = ...;
+User mutable = source; // ERROR
+```
+
+### Exemple 9
+
+```text
+User source = ...;
+const User readonly = source; // OK
+```
+
+### Exemple 10
+
+```text
+const int32 a = 10;
+int32 b = a; // OK
+b = 20;      // OK
+```
+
+### Exemple 11
+
+```text
+class Document {
+    const User owner;
+}
+```
+
+### Exemple 12
+
+```text
+this::owner = other;        // ERROR après initialisation
+this::owner::setName(...);  // ERROR via cet accès
+```
+
 ## DO / DON'T / WHY / compiler error / edge cases
 
-La couverture structurée de cette section sera enrichie au fur et à mesure de la fermeture des règles du chapitre. La migration `0.2.12` conserve volontairement les exemples historiques dans le chapitre afin de ne perdre aucun contexte normatif.
+À consolider progressivement avant la baseline publique V3 et à transformer, lorsque pertinent, en tests de conformité de la toolchain.

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

@@ -1,8 +1,8 @@
 # Exemples / DO-DON'T — Chapitre 15 — Fonctions, méthodes et `clsmethod`
 
-> Document compagnon non normatif tant qu'une règle n'est pas explicitement référencée comme normative par le chapitre.
+> Document compagnon. Les exemples illustrent les règles du chapitre ; la formulation normative reste dans le chapitre lui-même.
 
-## Exemples actuellement présents dans le chapitre
+## Exemples extraits du chapitre
 
 ### Exemple 1
 
@@ -48,6 +48,67 @@ return Result::Ok(value);
 return Result::Ok(Void);
 ```
 
+### Exemple 6
+
+```text
+class User {
+    const method getName() -> String {
+        return this::name;
+    }
+
+    method setName(String name) -> Void {
+        this::name = name;
+        return Void;
+    }
+}
+```
+
+### Exemple 7
+
+```text
+User a = ...;
+const User b = a;
+
+a::setName("John"); // OK
+a::getName();       // OK
+
+b::getName();       // OK
+b::setName("John"); // ERROR
+```
+
+### Exemple 8
+
+```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
+```
+
+### Exemple 9
+
+```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
+```
+
+### Exemple 10
+
+```text
+func display(const User user) -> Void
+```
+
+### Exemple 11
+
+```text
+const method getOwner() -> const User {
+    return this::owner;
+}
+```
+
 ## DO / DON'T / WHY / compiler error / edge cases
 
-La couverture structurée de cette section sera enrichie au fur et à mesure de la fermeture des règles du chapitre. La migration `0.2.12` conserve volontairement les exemples historiques dans le chapitre afin de ne perdre aucun contexte normatif.
+À consolider progressivement avant la baseline publique V3 et à transformer, lorsque pertinent, en tests de conformité de la toolchain.

examples/016-dispatch-override-et-modificateurs-examples.md

@@ -1,8 +1,8 @@
 # Exemples / DO-DON'T — Chapitre 16 — Dispatch, override et modificateurs
 
-> Document compagnon non normatif tant qu'une règle n'est pas explicitement référencée comme normative par le chapitre.
+> Document compagnon. Les exemples illustrent les règles du chapitre ; la formulation normative reste dans le chapitre lui-même.
 
-## Exemples actuellement présents dans le chapitre
+## Exemples extraits du chapitre
 
 ### Exemple 1
 
@@ -12,6 +12,7 @@ visibility
 -> linkage / ABI
 -> type / dispatch modifiers
 -> override
+-> access qualifier
 -> declaration kind
 ```
 
@@ -31,8 +32,9 @@ public open class Service
 public abstract class Base
 public unsafe extern "C" union NativeValue
 protected open method calculate(...)
+protected const method inspect(...)
 protected override method calculate(...)
-protected final override method calculate(...)
+protected final override const method inspect(...)
 ```
 
 ### Exemple 4
@@ -59,6 +61,16 @@ override method
 final override method
 ```
 
+### Exemple 8
+
+```text
+const method
+    doit être implémentée/overridée par const method
+
+method
+    doit être implémentée/overridée par method
+```
+
 ## DO / DON'T / WHY / compiler error / edge cases
 
-La couverture structurée de cette section sera enrichie au fur et à mesure de la fermeture des règles du chapitre. La migration `0.2.12` conserve volontairement les exemples historiques dans le chapitre afin de ne perdre aucun contexte normatif.
+À consolider progressivement avant la baseline publique V3 et à transformer, lorsque pertinent, en tests de conformité de la toolchain.

examples/021-strings-unicode-et-encodages-examples.md

@@ -1,31 +1,18 @@
 # Exemples / DO-DON'T — Chapitre 21 — Strings, Unicode et encodages
 
-> Document compagnon non normatif tant qu'une règle n'est pas explicitement référencée comme normative par le chapitre.
+> Document compagnon. Les exemples illustrent les règles du chapitre ; la formulation normative reste dans le chapitre lui-même.
 
-## Exemples actuellement présents dans le chapitre
+## Exemples extraits du chapitre
 
 ### Exemple 1
 
 ```text
-Utf8String
+String text = "abc";
-Utf16String
+text::append("def"); // OK
-Utf32String
-AsciiString éventuel
-Bytes
 ```
 
 ### Exemple 2
 
-```text
-byte
-code unit
-Unicode scalar
-code point
-grapheme cluster
-```
-
-### Exemple 3
-
 ```text
 'A'
 'é'
@@ -35,8 +22,184 @@ grapheme cluster
 '\u{1F600}'
 ```
 
+### Exemple 3
+
+```text
+Utf8Char
+Utf16Char
+Utf32Char
+
+Utf8String
+Utf16String
+Utf32String
+```
+
 ### Exemple 4
 
+```text
+Utf8Char
+    exactement un Unicode scalar encodé en UTF-8
+    1 à 4 uint8
+
+Utf16Char
+    exactement un Unicode scalar encodé en UTF-16
+    1 à 2 uint16
+
+Utf32Char
+    exactement un Unicode scalar encodé en UTF-32
+    1 uint32
+```
+
+### Exemple 5
+
+```text
+Utf8String
+    séquence UTF-8 valide
+
+Utf16String
+    séquence UTF-16 valide
+
+Utf32String
+    séquence UTF-32 valide
+```
+
+### Exemple 6
+
+```text
+UTF-8  -> uint8
+UTF-16 -> uint16
+UTF-32 -> uint32
+```
+
+### Exemple 7
+
+```text
+char::toUtf8Char()
+Utf8Char::toChar()
+Utf8Char::toUtf16Char()
+
+Utf8Char::tryFrom(uint8)
+Utf16Char::tryFrom(uint16)
+Utf32Char::tryFrom(uint32)
+
+Utf8Char::tryToUint8()
+Utf16Char::tryToUint16()
+Utf32Char::toUint32()
+```
+
+### Exemple 8
+
+```text
+Utf8String text = ...;
+Utf16Char value = ...;
+
+text::append(value);                // ERROR
+text::append(value::toUtf8Char());  // OK
+```
+
+### Exemple 9
+
+```text
+String text = ...;
+text[5]; // ERROR
+```
+
+### Exemple 10
+
+```text
+text::scalarAt(index) -> char
+text::scalarCount() -> uint64
+```
+
+### Exemple 11
+
+```text
+Utf8String[index]  -> uint8
+Utf16String[index] -> uint16
+Utf32String[index] -> uint32
+```
+
+### Exemple 12
+
+```text
+encodedCharAt(scalarIndex)
+    retourne le UtfXChar correspondant au scalar ordinal demandé
+
+scalarAt(scalarIndex)
+    retourne le char correspondant
+```
+
+### Exemple 13
+
+```text
+Utf8String::encodedCharAt(uint64)  -> Utf8Char
+Utf16String::encodedCharAt(uint64) -> Utf16Char
+Utf32String::encodedCharAt(uint64) -> Utf32Char
+
+Utf8String::scalarAt(uint64)  -> char
+Utf16String::scalarAt(uint64) -> char
+Utf32String::scalarAt(uint64) -> char
+```
+
+### Exemple 14
+
+```text
+scalarCount()
+```
+
+### Exemple 15
+
+```text
+codeUnitCount()
+scalarCount()
+```
+
+### Exemple 16
+
+```text
+String implements Iterable<char>
+```
+
+### Exemple 17
+
+```text
+code units
+encoded chars
+Unicode scalars
+```
+
+### Exemple 18
+
+```text
+codeUnits()
+encodedChars()
+scalars()
+```
+
+### Exemple 19
+
+```text
+String text = "abc";
+text::append("def");
+```
+
+### Exemple 20
+
+```text
+Utf8String text = ...;
+Utf8Char value = ...;
+
+text::append(value); // OK
+```
+
+### Exemple 21
+
+```text
+text[index] = 0xFF; // ERROR
+```
+
+### Exemple 22
+
 ```text
 "..."                 String normale, escapes actifs
 """..."""             String normale multiligne
@@ -55,56 +218,19 @@ cr"..."               chaîne C brute, réservé
 t"..."                template structuré, réservé
 ```
 
-### Exemple 5
+### Exemple 23
 
 ```text
-i"Hello {name}"
+\\
-i"Hello ${name}"
+\"
-```
+\'
-
+\n
-### Exemple 6
+\r
-
+\t
-```text
+\0
-"""
+\u{...}
-    first
-    second
-    """
-```
-
-### Exemple 7
-
-```text
-r"simple"
-r#"He said "hello"."#
-r##"contains "# inside"##
-```
-
-### Exemple 8
-
-```text
-r"""..."""
-r#"""..."""#
-```
-
-### Exemple 9
-
-```text
-\\      backslash
-\"      double quote
-\'      single quote
-\n      newline
-\r      carriage return
-\t      horizontal tab
-\0      NUL
-\u{...} Unicode scalar
-```
-
-### Exemple 10
-
-```text
-b"\x00\x7f\x80\xff"
 ```
 
 ## DO / DON'T / WHY / compiler error / edge cases
 
-La couverture structurée de cette section sera enrichie au fur et à mesure de la fermeture des règles du chapitre. La migration `0.2.12` conserve volontairement les exemples historiques dans le chapitre afin de ne perdre aucun contexte normatif.
+À consolider progressivement avant la baseline publique V3 et à transformer, lorsque pertinent, en tests de conformité de la toolchain.

examples/027-memoire-references-et-unsafe-examples.md

@@ -1,8 +1,8 @@
 # Exemples / DO-DON'T — Chapitre 27 — Mémoire, références et `unsafe`
 
-> Document compagnon non normatif tant qu'une règle n'est pas explicitement référencée comme normative par le chapitre.
+> Document compagnon. Les exemples illustrent les règles du chapitre ; la formulation normative reste dans le chapitre lui-même.
 
-## Exemples actuellement présents dans le chapitre
+## Exemples extraits du chapitre
 
 ### Exemple 1
 
@@ -39,6 +39,15 @@ unsafe constant
 unsafe field
 ```
 
+### Exemple 4
+
+```text
+mot-clé mut pour obtenir la mutabilité normale
+borrow checker visible dans la syntaxe
+lifetimes utilisateur omniprésents
+ownership annotations pour les usages ordinaires
+```
+
 ## DO / DON'T / WHY / compiler error / edge cases
 
-La couverture structurée de cette section sera enrichie au fur et à mesure de la fermeture des règles du chapitre. La migration `0.2.12` conserve volontairement les exemples historiques dans le chapitre afin de ne perdre aucun contexte normatif.
+À consolider progressivement avant la baseline publique V3 et à transformer, lorsque pertinent, en tests de conformité de la toolchain.

examples/047-concepts-rejetes-ou-deconseilles-examples.md

@@ -1,8 +1,8 @@
 # Exemples / DO-DON'T — Chapitre 47 — Concepts rejetés ou déconseillés
 
-> Document compagnon non normatif tant qu'une règle n'est pas explicitement référencée comme normative par le chapitre.
+> Document compagnon. Les exemples illustrent les règles du chapitre ; la formulation normative reste dans le chapitre lui-même.
 
-## Exemples actuellement présents dans le chapitre
+## Exemples extraits du chapitre
 
 ### Exemple 1
 
@@ -25,6 +25,9 @@ match guards `when` / `if`
 loop/until/repeat/unless comme synonymes de structures existantes
 magic getters/setters
 mandatory native GC
+immutability by default for ordinary variables/objects
+mandatory `mut` qualifier for ordinary mutation
+Rust-style user-visible borrow/lifetime syntax as the default programming model
 ```
 
 ### Exemple 2
@@ -40,4 +43,4 @@ transitive dependencies importables sans déclaration directe
 
 ## DO / DON'T / WHY / compiler error / edge cases
 
-La couverture structurée de cette section sera enrichie au fur et à mesure de la fermeture des règles du chapitre. La migration `0.2.12` conserve volontairement les exemples historiques dans le chapitre afin de ne perdre aucun contexte normatif.
+À consolider progressivement avant la baseline publique V3 et à transformer, lorsque pertinent, en tests de conformité de la toolchain.