v0.2.15
This commit is contained in:
@@ -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
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
104
MANIFEST.toml
104
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"
|
||||
|
||||
287
annexes/B-unicode-encoding-conversions.md
Normal file
287
annexes/B-unicode-encoding-conversions.md
Normal file
@@ -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.
|
||||
@@ -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.
|
||||
|
||||
---
|
||||
|
||||
@@ -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.
|
||||
|
||||
---
|
||||
|
||||
@@ -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.
|
||||
|
||||
---
|
||||
|
||||
@@ -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.
|
||||
|
||||
---
|
||||
|
||||
@@ -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<uint64,char>` 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<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 :
|
||||
|
||||
```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.
|
||||
|
||||
---
|
||||
|
||||
@@ -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.
|
||||
|
||||
---
|
||||
|
||||
@@ -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é
|
||||
|
||||
@@ -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.**
|
||||
|
||||
---
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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<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}"
|
||||
```
|
||||
|
||||
### 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.
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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.
|
||||
|
||||
Reference in New Issue
Block a user