diff --git a/000-README.md b/000-README.md index 29c2f4c..e8b9559 100644 --- a/000-README.md +++ b/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 diff --git a/001-SUMMARY.md b/001-SUMMARY.md index 7385579..43caf23 100644 --- a/001-SUMMARY.md +++ b/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 diff --git a/003-CHANGELOG.md b/003-CHANGELOG.md index 597173f..d57ca18 100644 --- a/003-CHANGELOG.md +++ b/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 diff --git a/MANIFEST.toml b/MANIFEST.toml index 04126eb..a9ba5c8 100644 --- a/MANIFEST.toml +++ b/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" -sha256 = "7e67ab02a99b7ebbb0d5ac0a16bdc89f70fdfdad0620a3927e3f07a13c722743" +path = "chapters/002-principes-generaux-du-langage.md" +sha256 = "d07d8c85dd2bd4502d10447e7b2f9782f0172038bba681b165d230f18b2360b0" [[modified]] -path = "chapters/001-trajectoire-dimplementation.md" -sha256 = "9f0205305e77f3474091795e897743c4e2012fc94a04a954509a7a6c3f3f43ed" +path = "chapters/006-types-variables-constantes-et-scopes.md" +sha256 = "1fa6a92649edec9a1a8393908a87fd297aebe4f9899cbadabd9fe8c8c4560f70" [[modified]] -path = "chapters/005-types-primitifs.md" -sha256 = "c723a1fde76ee90badae1d08deab9e7b8e59da6622979c3f89f3da495efe8157" +path = "chapters/015-fonctions-methodes-et-clsmethod.md" +sha256 = "eabe7b33970c42d6c08f31c8de147c6dcce46725b69abe52218686121028191f" [[modified]] -path = "chapters/007-types-nominaux-et-fichiers-saseltype.md" -sha256 = "1b853fb1160d397565988e3a8dbb9b52b8c5cfbca0c2428948221955728f715c" +path = "chapters/016-dispatch-override-et-modificateurs.md" +sha256 = "597d31ef050753fca9dd2017c5c3a0847afcfae067ca3ac66a45fd7494b5ba2d" [[modified]] -path = "chapters/014-generics.md" -sha256 = "c827e50f5efd51480e0fc250a3e92d75f40eaadc5d47b42078ae16b4c6c5f14a" +path = "chapters/021-strings-unicode-et-encodages.md" +sha256 = "617f15ca05d2676ea4b0db3c6abf023d1c793dc93aa08e7b588c27bf6bb74a42" [[modified]] -path = "chapters/024-casts-et-conversions.md" -sha256 = "d625afcee310a5c2eee2342ea96c86cd24f7185a91919849e05641b50ac47b58" +path = "chapters/027-memoire-references-et-unsafe.md" +sha256 = "aaa6d7928a107c5480d39761d5e50b3dd6d87db8402cfbe22302093b39fd913e" [[modified]] -path = "chapters/033-imports-et-resolution-des-noms.md" -sha256 = "9e392a4d7adf6c3569f50f6664709a64d3398ded98a6f5365eff5175a9f2a8b5" - -[[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" +path = "chapters/047-concepts-rejetes-ou-deconseilles.md" +sha256 = "4c038901eb53bac11be814e8d56359f7c6814d628a21c17dcd3f16f47fd45320" [[modified]] path = "chapters/051-invariants-de-conception.md" -sha256 = "b02f60468fe292bcfac773a98cf14b865d0fc1936bf353a299d02fec37579a19" +sha256 = "e27272b1f32546efbc188c3bb9225a128a795b33814648fca2f9e31137d54eab" [[modified]] -path = "chapters/052-priorite-de-specification-apres-0-2-9.md" -sha256 = "b8b47f694ea42489e0e83237cbb8c956a716227428e15d8f14c9237266e332a9" +path = "examples/002-principes-generaux-du-langage-examples.md" +sha256 = "ee17304997a099374265aef8b7934507740be3129df7adf0037488d7a536d3e0" [[modified]] -path = "examples/001-trajectoire-dimplementation-examples.md" -sha256 = "b66c40c7bfc9d76fe80e15f90fcef9c3ab8eabcdbec134fb3f660cfc2b79b5f9" +path = "examples/006-types-variables-constantes-et-scopes-examples.md" +sha256 = "daff10eb742465242b19436bc30edd797b127ede9ef326cb37bb68cd4495f5b9" [[modified]] -path = "examples/005-types-primitifs-examples.md" -sha256 = "9d131cd3874606d92988c2fc9ac24dc04c1349893f2be6678618cf13673a94ab" +path = "examples/015-fonctions-methodes-et-clsmethod-examples.md" +sha256 = "3ea40250b68ef69cc2186c7eb59baa17575b5ca07d3a6f289802cb9a89287140" [[modified]] -path = "examples/007-types-nominaux-et-fichiers-saseltype-examples.md" -sha256 = "a5e4dd8a36a63ea4aba31945379905ed76686b5849bbfb7f7690e5e8c3856ebd" +path = "examples/016-dispatch-override-et-modificateurs-examples.md" +sha256 = "5e34730cad71ac15bcdb10389da4116575d4e1876fee29c7c8a050ef46749dfa" [[modified]] -path = "examples/014-generics-examples.md" -sha256 = "c1912b3657b0633e9d143e069bd75eb079486d1f2de8e6cd67f374aa7edcd78b" +path = "examples/021-strings-unicode-et-encodages-examples.md" +sha256 = "5351ee93c4a6a15de77c5c6433b0ffdc91763846f0deeeb95838f403324ce623" [[modified]] -path = "examples/024-casts-et-conversions-examples.md" -sha256 = "5e402ca2584d2272b88a656d335ea8360224de937d75cab3b5c9f83efbf608af" +path = "examples/027-memoire-references-et-unsafe-examples.md" +sha256 = "700002e9cabd500a9a7fb505deaecec5d23fe31da1feda27df5f5169825e8a52" [[modified]] -path = "examples/033-imports-et-resolution-des-noms-examples.md" -sha256 = "2932904dce7683d2da856a6be78ba09f57ef1dd4d95c3df8c4280685d28c9003" - -[[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" +path = "examples/047-concepts-rejetes-ou-deconseilles-examples.md" +sha256 = "8cc0933a6f58a833c57dadeb8683a50c5225dcc461b8aac6824de23a54a9da3f" diff --git a/annexes/B-unicode-encoding-conversions.md b/annexes/B-unicode-encoding-conversions.md new file mode 100644 index 0000000..63e9020 --- /dev/null +++ b/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) +``` + +`N` utile : 1 à 4. Le contenu doit représenter exactement un scalar UTF-8 valide. + +UTF-16 : + +```text +Utf16Char::tryFrom(uint16) +Utf16Char::tryFrom(StaticArray) +``` + +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) +Utf16String::tryFrom(Array) +Utf32String::tryFrom(Array) +``` + +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` 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`. + +## 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. diff --git a/chapters/002-principes-generaux-du-langage.md b/chapters/002-principes-generaux-du-langage.md index dce78a9..6d9a418 100644 --- a/chapters/002-principes-generaux-du-langage.md +++ b/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. + --- diff --git a/chapters/006-types-variables-constantes-et-scopes.md b/chapters/006-types-variables-constantes-et-scopes.md index 5028061..e0f9e09 100644 --- a/chapters/006-types-variables-constantes-et-scopes.md +++ b/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. + --- diff --git a/chapters/015-fonctions-methodes-et-clsmethod.md b/chapters/015-fonctions-methodes-et-clsmethod.md index 67908e1..dd6f68d 100644 --- a/chapters/015-fonctions-methodes-et-clsmethod.md +++ b/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. + --- diff --git a/chapters/016-dispatch-override-et-modificateurs.md b/chapters/016-dispatch-override-et-modificateurs.md index 860508a..0b36137 100644 --- a/chapters/016-dispatch-override-et-modificateurs.md +++ b/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. + --- diff --git a/chapters/021-strings-unicode-et-encodages.md b/chapters/021-strings-unicode-et-encodages.md index 69507ce..a343223 100644 --- a/chapters/021-strings-unicode-et-encodages.md +++ b/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 -Utf16String -Utf32String -AsciiString éventuel -Bytes +String text = "abc"; +text::append("def"); // OK ``` -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 - -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` avant cette décision. - -## 21.4 `char` — V1 REQUIS — FIGÉ +## 21.2 `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 +``` + +Pour `Utf8String`, `Utf16String` et `Utf32String`, plusieurs parcours utiles existent : + +```text +code units +encoded chars +Unicode scalars +``` + +Aucun `Iterable` 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 : - -```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 - """ -``` +Les triples quotes fournissent la forme multiligne. 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é. - -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. +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é. 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 -r"""...""" -r#"""..."""# -``` +## 21.15 Source Unicode et représentation — V1 REQUIS — FIGÉ EN PRINCIPE -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. - -## 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. +La représentation physique interne de `String` reste indépendante de cette syntaxe source et peut varier suivant backend/target. --- diff --git a/chapters/027-memoire-references-et-unsafe.md b/chapters/027-memoire-references-et-unsafe.md index e04a42b..56035dc 100644 --- a/chapters/027-memoire-references-et-unsafe.md +++ b/chapters/027-memoire-references-et-unsafe.md @@ -76,4 +76,21 @@ Les noms des types (`Ptr`, `PtrMut` 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. + --- diff --git a/chapters/047-concepts-rejetes-ou-deconseilles.md b/chapters/047-concepts-rejetes-ou-deconseilles.md index 5c33b63..0c9be47 100644 --- a/chapters/047-concepts-rejetes-ou-deconseilles.md +++ b/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é diff --git a/chapters/051-invariants-de-conception.md b/chapters/051-invariants-de-conception.md index 1119d3e..045f20a 100644 --- a/chapters/051-invariants-de-conception.md +++ b/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.** --- diff --git a/examples/002-principes-generaux-du-langage-examples.md b/examples/002-principes-generaux-du-langage-examples.md index c045f6e..baf059f 100644 --- a/examples/002-principes-generaux-du-langage-examples.md +++ b/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> } ``` +### 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. diff --git a/examples/006-types-variables-constantes-et-scopes-examples.md b/examples/006-types-variables-constantes-et-scopes-examples.md index 522abad..a4755f7 100644 --- a/examples/006-types-variables-constantes-et-scopes-examples.md +++ b/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. diff --git a/examples/015-fonctions-methodes-et-clsmethod-examples.md b/examples/015-fonctions-methodes-et-clsmethod-examples.md index b9b5619..05f6ac7 100644 --- a/examples/015-fonctions-methodes-et-clsmethod-examples.md +++ b/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. diff --git a/examples/016-dispatch-override-et-modificateurs-examples.md b/examples/016-dispatch-override-et-modificateurs-examples.md index d9947fd..defe5b3 100644 --- a/examples/016-dispatch-override-et-modificateurs-examples.md +++ b/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. diff --git a/examples/021-strings-unicode-et-encodages-examples.md b/examples/021-strings-unicode-et-encodages-examples.md index 68b6f50..3a82333 100644 --- a/examples/021-strings-unicode-et-encodages-examples.md +++ b/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 -Utf16String -Utf32String -AsciiString éventuel -Bytes +String text = "abc"; +text::append("def"); // OK ``` ### 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 +``` + +### 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}" -``` - -### Exemple 6 - -```text -""" - 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" +\\ +\" +\' +\n +\r +\t +\0 +\u{...} ``` ## 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. diff --git a/examples/027-memoire-references-et-unsafe-examples.md b/examples/027-memoire-references-et-unsafe-examples.md index b0b5bc4..4951cac 100644 --- a/examples/027-memoire-references-et-unsafe-examples.md +++ b/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. diff --git a/examples/047-concepts-rejetes-ou-deconseilles-examples.md b/examples/047-concepts-rejetes-ou-deconseilles-examples.md index 245d1c6..f0d01f4 100644 --- a/examples/047-concepts-rejetes-ou-deconseilles-examples.md +++ b/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.