v0.2.16

2026-09-13 00:12:41 +02:00
parent fd4e879c0c
commit 019c8ad335
16 changed files with 580 additions and 92 deletions
--- a/000-README.md
+++ b/000-README.md
@@ -1,4 +1,4 @@
-# Bible Saselang 0.2.15
+# Bible Saselang 0.2.16

 > **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.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.
+> **Révision 0.2.16 :** formalisation des arrays/slices et de leur initialisation, hiérarchie de capacités de collections (`Collection`, `List`, `SettableList`, `ResizableList`), sous-chaînes à stockage partageable et politique des bibliothèques officielles `.saselib`.

 ## Organisation de cette distribution

--- a/001-SUMMARY.md
+++ b/001-SUMMARY.md
@@ -1,4 +1,4 @@
-# Sommaire — Bible Saselang 0.2.15
+# Sommaire — Bible Saselang 0.2.16

 ## Chapitres

--- a/003-CHANGELOG.md
+++ b/003-CHANGELOG.md
@@ -1,4 +1,23 @@
-# Changelog documentaire — 0.2.15
+# Changelog documentaire — 0.2.16
+
+## 0.2.16
+
+- `Array<T>` fixé comme séquence contiguë de longueur runtime fixe ;
+- `StaticArray<T,N>` fixé comme séquence contiguë de longueur compile-time fixe ;
+- `Slice<T>` défini comme vue contiguë fixe, non redimensionnable/non déplaçable et sans copie sémantique ;
+- propagation de `const` vers les slices et leurs éléments, sans lifetimes utilisateur visibles ;
+- initialisation complète obligatoire des arrays avant observation safe ;
+- littéraux `[...]`, `filled`, `empty` et principe de `generate` définis ;
+- `filled()` répète selon la sémantique normale de `T` et ne clone jamais implicitement les objets de classe ;
+- `Collection<T>` distingue `count()` ; `List<T>` ajoute la sémantique de séquence et `length()` ;
+- hiérarchie `Iterable -> Collection -> List -> SettableList -> ResizableList` retenue ;
+- `List<T>` repose sur `OpIndex<uint64,T>` et `SettableList<T>` ajoute `OpIndexMut<uint64,T>` ;
+- capacité intrinsèque et permission `const` explicitement séparées ;
+- `String::substring()` produit une `String` sémantiquement indépendante tout en autorisant le partage physique interne ;
+- aucun `StringView` introduit ni réservé ;
+- ajout d'une couche de bibliothèques officielles `.saselib`, sans notion spéciale d'addon ;
+- politique de bootstrap natif puis remplacement progressif par des saselib Saselang ;
+- `saselang/mapdb*` retenu comme exemple de famille officielle spécialisée.

 ## 0.2.15

--- a/MANIFEST.toml
+++ b/MANIFEST.toml
@@ -1,81 +1,65 @@
 format = 1
-version = "0.2.15"
+version = "0.2.16"
 distribution = "delta"
-base_version = "0.2.14"
+base_version = "0.2.15"
 documentation_layout = "multifile"

-[[added]]
-path = "annexes/B-unicode-encoding-conversions.md"
-sha256 = "b6baa4f94d70eb82bf8922cc95e8b388c39a7e22d0c38d3b4f277b72f7fc2a45"
-
 [[modified]]
 path = "000-README.md"
-sha256 = "648bf6155fba691146a724ebaecbeedca73a2d55d5a17539a1b2926e97c9751f"
+sha256 = "4b4d422dcc52991e38c6cb1b7b92aeb391ca0b7d6bc1c8da0de4de6169c93b7a"

 [[modified]]
 path = "001-SUMMARY.md"
-sha256 = "7f1a95bdf99224c983e1d91fda0bce4b74c656aa6067412c8f292a73097e9fb5"
+sha256 = "2cf8811903512dc58739c4d16e2696d10bcb36f2b767d3e5eccf038013ef1a66"

 [[modified]]
 path = "003-CHANGELOG.md"
-sha256 = "8f3ea4ad3c3d2f41848851f419baf5d7c6f9aa06f27a9ea84ea42be2ae957775"
+sha256 = "0f78fefe1d630ebc0587b7bb0865f77c34b9782562bf47af6d86e82cac8bf738"

 [[modified]]
-path = "chapters/002-principes-generaux-du-langage.md"
-sha256 = "d07d8c85dd2bd4502d10447e7b2f9782f0172038bba681b165d230f18b2360b0"
-
-[[modified]]
-path = "chapters/006-types-variables-constantes-et-scopes.md"
-sha256 = "1fa6a92649edec9a1a8393908a87fd297aebe4f9899cbadabd9fe8c8c4560f70"
-
-[[modified]]
-path = "chapters/015-fonctions-methodes-et-clsmethod.md"
-sha256 = "eabe7b33970c42d6c08f31c8de147c6dcce46725b69abe52218686121028191f"
-
-[[modified]]
-path = "chapters/016-dispatch-override-et-modificateurs.md"
-sha256 = "597d31ef050753fca9dd2017c5c3a0847afcfae067ca3ac66a45fd7494b5ba2d"
+path = "chapters/004-couches-de-lecosysteme-v1.md"
+sha256 = "5d6bfbc9e9d7c5253fbe470c114a2b2394c16cf62a5cd7efd3d9f40252ae0106"

 [[modified]]
 path = "chapters/021-strings-unicode-et-encodages.md"
-sha256 = "617f15ca05d2676ea4b0db3c6abf023d1c793dc93aa08e7b588c27bf6bb74a42"
+sha256 = "3350f8581eb43343136caf7cf808b25da4543edac6b176ad61d3e40292b19d76"

 [[modified]]
-path = "chapters/027-memoire-references-et-unsafe.md"
-sha256 = "aaa6d7928a107c5480d39761d5e50b3dd6d87db8402cfbe22302093b39fd913e"
+path = "chapters/022-collections-et-iteration.md"
+sha256 = "a60534eef7f12201b238c7a4899b46c8be4df3535f293978e05471cc210c3d7a"

 [[modified]]
-path = "chapters/047-concepts-rejetes-ou-deconseilles.md"
-sha256 = "4c038901eb53bac11be814e8d56359f7c6814d628a21c17dcd3f16f47fd45320"
+path = "chapters/037-dependances-et-scopes.md"
+sha256 = "64335ed6b00a8133718384e49b34be0f362569b9b177a35da963543abe603a9a"
+
+[[modified]]
+path = "chapters/048-inventaire-des-points-v1-encore-ouverts.md"
+sha256 = "3c99a2d2901e5843b4ea40b26c541203c907a809ad2004fd93c0ad4a94a68413"

 [[modified]]
 path = "chapters/051-invariants-de-conception.md"
-sha256 = "e27272b1f32546efbc188c3bb9225a128a795b33814648fca2f9e31137d54eab"
+sha256 = "05c23658ea2b127c023b5d75630bd79096934d21f04f67f01375486fd35386e4"

 [[modified]]
-path = "examples/002-principes-generaux-du-langage-examples.md"
-sha256 = "ee17304997a099374265aef8b7934507740be3129df7adf0037488d7a536d3e0"
-
-[[modified]]
-path = "examples/006-types-variables-constantes-et-scopes-examples.md"
-sha256 = "daff10eb742465242b19436bc30edd797b127ede9ef326cb37bb68cd4495f5b9"
-
-[[modified]]
-path = "examples/015-fonctions-methodes-et-clsmethod-examples.md"
-sha256 = "3ea40250b68ef69cc2186c7eb59baa17575b5ca07d3a6f289802cb9a89287140"
-
-[[modified]]
-path = "examples/016-dispatch-override-et-modificateurs-examples.md"
-sha256 = "5e34730cad71ac15bcdb10389da4116575d4e1876fee29c7c8a050ef46749dfa"
+path = "examples/004-couches-de-lecosysteme-v1-examples.md"
+sha256 = "3b37dee80e15c28fde237d208da3b16885c3190603f074b3bf4fabc21cda13e8"

 [[modified]]
 path = "examples/021-strings-unicode-et-encodages-examples.md"
-sha256 = "5351ee93c4a6a15de77c5c6433b0ffdc91763846f0deeeb95838f403324ce623"
+sha256 = "e065baa54cd9203f9b37883f5c418baea27ffc0fe4d28e97ff349a1b66f8adc7"

 [[modified]]
-path = "examples/027-memoire-references-et-unsafe-examples.md"
-sha256 = "700002e9cabd500a9a7fb505deaecec5d23fe31da1feda27df5f5169825e8a52"
+path = "examples/022-collections-et-iteration-examples.md"
+sha256 = "86749fa6c85fbfbc2cd18643ad1da639af76222845ebf4418e62f7744cb76003"

 [[modified]]
-path = "examples/047-concepts-rejetes-ou-deconseilles-examples.md"
-sha256 = "8cc0933a6f58a833c57dadeb8683a50c5225dcc461b8aac6824de23a54a9da3f"
+path = "examples/037-dependances-et-scopes-examples.md"
+sha256 = "a384f5a4c624f75f7a52186c731fc95890fb0ee5067788b4f93b90b0989774e1"
+
+[[modified]]
+path = "examples/048-inventaire-des-points-v1-encore-ouverts-examples.md"
+sha256 = "069383c40e74b495cdd3ccbebd87850654fa1ef4b6095e93a4eab14acb5d1f3d"
+
+[[modified]]
+path = "examples/051-invariants-de-conception-examples.md"
+sha256 = "307da7506d8411f033cfcfbf5fc555651175e28e64119e248a1c4d341afa487f"
--- a/chapters/004-couches-de-lecosysteme-v1.md
+++ b/chapters/004-couches-de-lecosysteme-v1.md
@@ -86,7 +86,25 @@ plateforme

 Le découpage exact Core/SDK doit être finalisé avant gel de l'API V1.

-## 4.4 Runtime réduit — V1 REQUIS — FIGÉ EN PRINCIPE
+## 4.4 Bibliothèques officielles `.saselib` — DIRECTION FIGÉE
+
+Au-delà du Core et du SDK, l'écosystème Saselang peut fournir des familles de bibliothèques officielles distribuées au format `.saselib`.
+
+Aucune notion spécifique d'« addon » n'est introduite.
+
+Ces bibliothèques restent optionnelles et versionnées indépendamment lorsque leur fonction ne justifie pas une présence obligatoire dans le SDK.
+
+Leur nom peut refléter directement la famille fonctionnelle concernée. Une famille de moteur embarqué inspirée de MapDB peut ainsi employer des noms du type :
+
+```text
+saselang/mapdb*
+```
+
+sans obligation de la cacher derrière une hiérarchie générique `saselang/storage*`.
+
+Le même principe s'applique aux futurs portages/réimplémentations spécialisés.
+
+## 4.5 Runtime réduit — V1 REQUIS — FIGÉ EN PRINCIPE

 Une application native simple ne doit pas être forcée d'embarquer un runtime monolithique.

--- a/chapters/021-strings-unicode-et-encodages.md
+++ b/chapters/021-strings-unicode-et-encodages.md
@@ -341,4 +341,26 @@ Une séquence UTF-8 invalide est une erreur de source.

 La représentation physique interne de `String` reste indépendante de cette syntaxe source et peut varier suivant backend/target.

+
+## 21.16 Sous-chaînes et représentation interne — V1 REQUIS — FIGÉ EN PRINCIPE
+
+La représentation interne de `String` n'est pas observable.
+
+Une implémentation peut notamment employer un stockage contigu, partagé, segmenté, copy-on-write, rope, small-string optimization ou une combinaison de ces techniques.
+
+`substring(...)` retourne une vraie `String` sémantiquement indépendante.
+
+```text
+String a = "abcdef";
+String b = a::substring(1..<4);
+```
+
+`b` représente indépendamment `"bcd"`.
+
+Une mutation ultérieure de `a` ne peut pas modifier la valeur observable de `b`, et inversement.
+
+Cette indépendance sémantique n'impose aucune copie physique immédiate : le runtime peut partager des segments/backing storage tant que le contrat reste respecté.
+
+Aucun type `StringView` n'est introduit ni réservé à ce stade. Il ne sera étudié que si un besoin concret apparaît.
+
 ---
--- a/chapters/022-collections-et-iteration.md
+++ b/chapters/022-collections-et-iteration.md
@@ -1,26 +1,159 @@
 # 22. Collections et itération

-## 22.1 `Array<T>` — V1 REQUIS — DIRECTION FIGÉE
+## 22.1 `Array<T>` — V1 REQUIS — FIGÉ EN PRINCIPE

-`Array<T>` est une séquence contiguë dont la taille est fixée lors de la création et n'est pas redimensionnable.
+`Array<T>` est une séquence contiguë dont la longueur est déterminée au runtime lors de la construction et reste fixe ensuite.

-## 22.2 `StaticArray<T,N>` — V1 REQUIS — DIRECTION FIGÉE
+Il n'expose pas d'opération structurelle de redimensionnement.

-`StaticArray<T,N>` est un tableau à taille connue à la compilation.
-
-Le mécanisme exact de const generics nécessaire à `N` doit être défini avec les generics.
-
-## 22.3 Collection redimensionnable — V1 REQUIS — À FINALISER
-
-Un type du type :
+Les éléments suivent exactement la sémantique normale de `T` :

 ```text
-Vector<T>
+T primitif -> valeur by-value
+T struct   -> valeur by-value
+T class    -> référence de classe
 ```

-est envisagé pour les séquences redimensionnables, mais l'API et le nom final doivent être figés dans le SDK V1.
+Copier un `Array<T>` crée une collection indépendante. Les éléments eux-mêmes sont copiés selon la sémantique normale de `T`.

-## 22.4 `Iterable<T>` / `Iterator<T>` — V1 REQUIS — FIGÉ
+Pour `Array<User>`, deux arrays copiés peuvent donc contenir des références vers les mêmes objets `User`, tout en restant indépendants quant au remplacement de leurs cases.
+
+### 22.1.1 Initialisation complète
+
+Un `Array<T>` safe doit être entièrement initialisé avant de devenir observable.
+
+Il n'existe aucune initialisation implicite en zéro, `null`, `None` ou valeur indéfinie.
+
+```text
+Array<int32> values = [1, 2, 3];
+Array<int32> empty = [];
+```
+
+Le littéral `[...]` est contextualisé par le type attendu ; il ne reçoit pas automatiquement un type autonome hors contexte suffisant.
+
+Les expressions d'un littéral d'array sont évaluées exactement une fois, de gauche à droite. En cas d'échec pendant la construction, aucun array partiellement initialisé ne devient observable.
+
+### 22.1.2 `filled`
+
+```text
+Array<T>::filled(uint64 length, T value)
+```
+
+`value` est évaluée une seule fois, puis répétée selon la sémantique normale de copie de `T`.
+
+```text
+User firstUser = ...;
+User otherUser = ...;
+
+Array<User> users = Array<User>::filled(3, firstUser);
+users[1] = otherUser; // OK si l'accès n'est pas const
+```
+
+Initialement, les trois cases contiennent la même référence `firstUser`. Chaque case reste cependant un emplacement indépendant et peut recevoir ultérieurement une autre référence.
+
+`filled()` ne clone jamais implicitement un objet référencé.
+
+### 22.1.3 `empty` et `generate`
+
+```text
+Array<T>::empty()
+```
+
+construit un array de longueur zéro.
+
+Une opération `generate` est retenue conceptuellement pour construire une valeur distincte par index. Sa syntaxe exacte sera figée avec les callables/lambdas.
+
+La factory devra être appelée exactement une fois par index, dans l'ordre croissant, sans parallélisation implicite.
+
+Le safe code ne peut pas obtenir un `Array<T>` observable partiellement/non initialisé. Le compilateur/runtime reste libre d'utiliser de la mémoire non initialisée en interne tant qu'elle n'est jamais observable.
+
+## 22.2 `StaticArray<T,N>` — V1 REQUIS — FIGÉ
+
+`StaticArray<T,N>` est une séquence contiguë dont la longueur `N` est connue à la compilation et reste fixe.
+
+```text
+StaticArray<int32, 3> values = [10, 20, 30];
+StaticArray<int32, 0> empty = [];
+```
+
+Le nombre d'éléments du littéral doit correspondre exactement à `N`.
+
+Une initialisation répétée utilise :
+
+```text
+StaticArray<T,N>::filled(T value)
+```
+
+avec la même sémantique de copie que `Array<T>::filled`.
+
+`StaticArray<T,N>` n'autorise pas davantage qu'`Array<T>` l'observation d'éléments non initialisés.
+
+## 22.3 `Slice<T>` — V1 REQUIS — FIGÉ EN PRINCIPE
+
+`Slice<T>` est une vue contiguë, de longueur fixe, sur une portion d'un stockage existant.
+
+Une slice ne réalise aucune copie sémantique des éléments.
+
+```text
+Array<int32> values = ...;
+Slice<int32> part = values::slice(10..<20);
+
+part[0] = 42; // modifie values[10]
+```
+
+Une slice :
+
+```text
+reste attachée à la portion qu'elle désigne
+conserve une longueur fixe
+n'est pas redimensionnable
+n'est pas déplaçable vers une autre portion
+peut modifier les éléments uniquement si l'accès source l'autorise
+ne peut jamais augmenter les droits de mutabilité de la source
+```
+
+La constness se propage :
+
+```text
+const Array<User> users = ...;
+const Slice<User> part = users::slice(0..<4);
+
+part[0] = otherUser;       // ERROR
+part[0]::setName("Alice"); // ERROR
+part[0]::getName();        // OK
+```
+
+Le backing storage nécessaire à une slice reste vivant aussi longtemps que nécessaire. Cette garantie ne requiert aucune syntaxe de lifetime utilisateur.
+
+Une slice vide est une valeur valide.
+
+Les indices d'une sous-slice sont relatifs à la slice source.
+
+`Slice<T>` garantit la contiguïté. Une éventuelle vue non contiguë constituerait un autre concept et n'est pas réservée sans besoin réel.
+
+## 22.4 Interfaces de collections — V1 REQUIS — FIGÉ EN PRINCIPE
+
+Les interfaces décrivent des capacités réellement garanties. Les classes/structs génériques fournissent le stockage et l'implémentation.
+
+Saselang ne retient pas le modèle d'opérations optionnelles qui existent dans une interface mais échouent ensuite au runtime comme « unsupported ».
+
+Hiérarchie principale retenue :
+
+```text
+Iterable<T>
+    ↓
+Collection<T>
+    ↓
+List<T>
+    ↓
+SettableList<T>
+    ↓
+ResizableList<T>
+```
+
+`Set<T>` et `Map<K,V>` sont des branches distinctes à préciser.
+
+### 22.4.1 `Iterable<T>` / `Iterator<T>`

 Interfaces Core reconnues par `foreach`.

@@ -28,6 +161,107 @@ Elles ne portent pas le préfixe `Op`, car `foreach` est une construction du lan

 Indexabilité et itérabilité sont indépendantes.

+### 22.4.2 `Collection<T>`
+
+`Collection<T>` étend `Iterable<T>` et représente une collection finie d'éléments.
+
+Contrat minimal retenu :
+
+```text
+count() -> uint64
+isEmpty() -> bool
+contains(const T value) -> bool
+```
+
+`count()` exprime le nombre d'éléments au sens général de collection.
+
+### 22.4.3 `List<T>`
+
+`List<T>` étend `Collection<T>` et `OpIndex<uint64,T>`.
+
+Elle garantit :
+
+```text
+ordre stable
+indexation positionnelle en lecture
+length() -> uint64
+```
+
+Pour une `List<T>` :
+
+```text
+count() == length()
+```
+
+Les deux noms sont néanmoins conservés parce qu'ils expriment des concepts différents : cardinalité générale de collection et longueur d'une séquence indexable.
+
+`List<T>` ne garantit ni remplacement d'un élément, ni redimensionnement, ni complexité algorithmique particulière de l'accès indexé.
+
+### 22.4.4 `SettableList<T>`
+
+`SettableList<T>` étend `List<T>` et `OpIndexMut<uint64,T>`.
+
+Elle garantit le remplacement d'un élément existant sans modification de la longueur.
+
+```text
+list[index] = value;
+```
+
+ne signifie jamais `append` lorsque `index == length()`.
+
+### 22.4.5 `ResizableList<T>`
+
+`ResizableList<T>` étend `SettableList<T>`.
+
+Elle garantit des opérations structurelles capables de modifier la longueur, par exemple ajout, insertion et suppression.
+
+Les signatures exactes seront figées lors de la définition du type concret redimensionnable.
+
+Un `resize(newLength)` sans information d'initialisation n'est pas retenu implicitement : agrandir une collection doit toujours définir comment les nouveaux éléments sont construits.
+
+### 22.4.6 Capacité du type et permission `const`
+
+La capacité intrinsèque du type et la permission d'un accès sont deux dimensions distinctes.
+
+```text
+SettableList<User> users = ...;
+const SettableList<User> readonly = users;
+```
+
+Le type sait remplacer des éléments, mais l'accès `readonly` ne peut pas utiliser cette capacité.
+
+La propagation générale de `const` reste applicable aux éléments obtenus via cet accès.
+
+### 22.4.7 Classification initiale
+
+```text
+StaticArray<T,N>
+    List<T>
+    SettableList<T>
+    pas ResizableList<T>
+
+Array<T>
+    List<T>
+    SettableList<T>
+    pas ResizableList<T>
+
+Slice<T>
+    List<T>
+    SettableList<T>
+    pas ResizableList<T>
+
+Vector<T>
+    List<T>
+    SettableList<T>
+    ResizableList<T>
+```
+
+`Vector<T>` reste à définir précisément.
+
+Un type persistant/immutable par nature n'a aucune obligation d'implémenter `List<T>`. Par exemple, un futur `PersistentList<T>` peut implémenter uniquement `Collection<T>` et fournir ses propres opérations si cela correspond mieux à sa sémantique.
+
+Une interface Saselang n'est jamais implémentée uniquement parce qu'un type ressemble conceptuellement à une autre famille de types.
+
 ## 22.5 `Range<T>` — V1 REQUIS — FIGÉ EN PRINCIPE

 `Range<T>` est une vraie valeur Saselang immuable représentant un intervalle ordonné. Il ne représente ni un pas ni une progression d'itération.
--- a/chapters/037-dependances-et-scopes.md
+++ b/chapters/037-dependances-et-scopes.md
@@ -328,3 +328,34 @@ Même principe pour `func`, `const` et `var`.
 Le `from` doit référencer un selector effectivement déclaré dans le graphe effectif du fichier. Il ne déclenche aucune résolution indépendante.

 La qualification complète sans import reste limitée aux symboles du package courant.
+
+
+## 37.10 Politique de bootstrap natif et remplacement progressif — DIRECTION FIGÉE
+
+Les premières générations de Saselang peuvent s'appuyer largement sur des bibliothèques natives existantes afin d'accélérer le bootstrap de la toolchain et de l'écosystème.
+
+Cette dépendance initiale n'est pas considérée comme l'architecture finale souhaitée.
+
+La trajectoire retenue consiste à réimplémenter, porter, adapter ou améliorer progressivement les composants pertinents en Saselang, puis à les distribuer sous forme de bibliothèques `.saselib`.
+
+Les familles envisagées peuvent inclure notamment :
+
+```text
+MapDB-like
+RocksDB-like
+PostgreSQL-compatible components
+SDL-like multimedia
+WebKit/WebView integrations ou remplacements
+bibliothèques image/audio/vidéo
+outils UI et multimedia
+```
+
+Ces noms désignent des directions d'écosystème, pas des APIs déjà réservées.
+
+L'objectif à long terme est de réduire les dépendances natives au strict minimum nécessaire au target. La libc ou son équivalent peut rester utilisée si sa substitution complète n'est pas raisonnable ou n'apporte pas de bénéfice suffisant.
+
+Une réimplémentation Saselang n'est pas tenue de reproduire aveuglément l'architecture d'origine : elle peut corriger, simplifier, étendre ou améliorer l'API et l'implémentation.
+
+L'ambition est de permettre progressivement un écosystème de bibliothèques comparable ou supérieur en richesse fonctionnelle à de grands ensembles tels que Qt ou GTK, sans transformer ces bibliothèques spécialisées en obligations du langage/Core/SDK.
+
+---
--- a/chapters/048-inventaire-des-points-v1-encore-ouverts.md
+++ b/chapters/048-inventaire-des-points-v1-encore-ouverts.md
@@ -23,7 +23,7 @@ Restent à fermer :
 - callable/function types ;
 - lambdas/closures ;
 - variadiques (un seul variadique prévu) ;
- String/index Unicode ;
+- String : APIs avancées restantes (graphemes, normalisation/collation, builders/buffers spécialisés) ;
 - exact float semantics hors conversions déjà figées (opérations arithmétiques IEEE restantes, `%`, division par zéro, etc.).

 ## 48.3 Mémoire
--- a/chapters/051-invariants-de-conception.md
+++ b/chapters/051-invariants-de-conception.md
@@ -28,4 +28,11 @@ Les futures décisions doivent respecter les invariants suivants :
 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.**

+26. **Une interface de collection n'annonce jamais une capacité qui peut être absente et échouer ensuite comme « unsupported ».**
+27. **Capacité intrinsèque d'un type et permission portée par `const` restent deux dimensions distinctes.**
+28. **Une slice ne peut jamais augmenter les droits de mutation de sa source.**
+29. **Un array safe devient observable uniquement après initialisation complète.**
+30. **Une bibliothèque spécialisée peut être officielle sans appartenir au Core ou au SDK obligatoire ; son artifact normal reste une `.saselib`.**
+31. **Les dépendances natives de bootstrap peuvent être remplacées progressivement par des implémentations Saselang sans imposer leur architecture historique au langage.**
+
 ---
--- a/examples/004-couches-de-lecosysteme-v1-examples.md
+++ b/examples/004-couches-de-lecosysteme-v1-examples.md
@@ -1,8 +1,8 @@
 # Exemples / DO-DON'T — Chapitre 4 — Couches de l'écosystème V1

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

@@ -72,6 +72,12 @@ FFI helpers
 plateforme
 ```

+### Exemple 4
+
+```text
+saselang/mapdb*
+```
+
 ## 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.
--- a/examples/021-strings-unicode-et-encodages-examples.md
+++ b/examples/021-strings-unicode-et-encodages-examples.md
@@ -231,6 +231,13 @@ t"..."                template structuré, réservé
 \u{...}
 ```

+### Exemple 24
+
+```text
+String a = "abcdef";
+String b = a::substring(1..<4);
+```
+
 ## DO / DON'T / WHY / compiler error / edge cases

 À consolider progressivement avant la baseline publique V3 et à transformer, lorsque pertinent, en tests de conformité de la toolchain.
--- a/examples/022-collections-et-iteration-examples.md
+++ b/examples/022-collections-et-iteration-examples.md
@@ -1,17 +1,165 @@
 # Exemples / DO-DON'T — Chapitre 22 — Collections et itération

-> 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
-Vector<T>
+T primitif -> valeur by-value
+T struct   -> valeur by-value
+T class    -> référence de classe
 ```

 ### Exemple 2

+```text
+Array<int32> values = [1, 2, 3];
+Array<int32> empty = [];
+```
+
+### Exemple 3
+
+```text
+Array<T>::filled(uint64 length, T value)
+```
+
+### Exemple 4
+
+```text
+User firstUser = ...;
+User otherUser = ...;
+
+Array<User> users = Array<User>::filled(3, firstUser);
+users[1] = otherUser; // OK si l'accès n'est pas const
+```
+
+### Exemple 5
+
+```text
+Array<T>::empty()
+```
+
+### Exemple 6
+
+```text
+StaticArray<int32, 3> values = [10, 20, 30];
+StaticArray<int32, 0> empty = [];
+```
+
+### Exemple 7
+
+```text
+StaticArray<T,N>::filled(T value)
+```
+
+### Exemple 8
+
+```text
+Array<int32> values = ...;
+Slice<int32> part = values::slice(10..<20);
+
+part[0] = 42; // modifie values[10]
+```
+
+### Exemple 9
+
+```text
+reste attachée à la portion qu'elle désigne
+conserve une longueur fixe
+n'est pas redimensionnable
+n'est pas déplaçable vers une autre portion
+peut modifier les éléments uniquement si l'accès source l'autorise
+ne peut jamais augmenter les droits de mutabilité de la source
+```
+
+### Exemple 10
+
+```text
+const Array<User> users = ...;
+const Slice<User> part = users::slice(0..<4);
+
+part[0] = otherUser;       // ERROR
+part[0]::setName("Alice"); // ERROR
+part[0]::getName();        // OK
+```
+
+### Exemple 11
+
+```text
+Iterable<T>
+    ↓
+Collection<T>
+    ↓
+List<T>
+    ↓
+SettableList<T>
+    ↓
+ResizableList<T>
+```
+
+### Exemple 12
+
+```text
+count() -> uint64
+isEmpty() -> bool
+contains(const T value) -> bool
+```
+
+### Exemple 13
+
+```text
+ordre stable
+indexation positionnelle en lecture
+length() -> uint64
+```
+
+### Exemple 14
+
+```text
+count() == length()
+```
+
+### Exemple 15
+
+```text
+list[index] = value;
+```
+
+### Exemple 16
+
+```text
+SettableList<User> users = ...;
+const SettableList<User> readonly = users;
+```
+
+### Exemple 17
+
+```text
+StaticArray<T,N>
+    List<T>
+    SettableList<T>
+    pas ResizableList<T>
+
+Array<T>
+    List<T>
+    SettableList<T>
+    pas ResizableList<T>
+
+Slice<T>
+    List<T>
+    SettableList<T>
+    pas ResizableList<T>
+
+Vector<T>
+    List<T>
+    SettableList<T>
+    ResizableList<T>
+```
+
+### Exemple 18
+
 ```text
 a..b        [a, b]    bornes basse et haute incluses
 a>..b       (a, b]    borne basse exclue, borne haute incluse
@@ -19,13 +167,13 @@ a..<b       [a, b)    borne basse incluse, borne haute exclue
 a>..<b      (a, b)    bornes basse et haute exclues
 ```

-### Exemple 3
+### Exemple 19

 ```text
 Range<uint64> ids = 1..100;
 ```

-### Exemple 4
+### Exemple 20

 ```text
 NaN                  interdit comme borne
@@ -34,7 +182,7 @@ NaN                  interdit comme borne
 valeur finie         autorisée
 ```

-### Exemple 5
+### Exemple 21

 ```text
 a..a        contient exactement a
@@ -43,7 +191,7 @@ a..<a       vide
 a>..<a      vide
 ```

-### Exemple 6
+### Exemple 22

 ```text
 range::lower()
@@ -54,7 +202,7 @@ range::isEmpty()
 range::contains(value)
 ```

-### Exemple 7
+### Exemple 23

 ```text
 Range<T>                         intervalle ordonné
@@ -65,13 +213,13 @@ RangeReverseStep<T,Step>         parcours arrière avec pas explicite
 RangeProgression<T,Step>         valeur de progression produite
 ```

-### Exemple 8
+### Exemple 24

 ```text
 (range)::step(step)
 ```

-### Exemple 9
+### Exemple 25

 ```text
 RangeStep<int32,int32>
@@ -80,14 +228,14 @@ RangeStep<char,uint32>
 RangeStep<Date,Duration>
 ```

-### Exemple 10
+### Exemple 26

 ```text
 (range)::reverse()
 (range)::reverse()::step(step)
 ```

-### Exemple 11
+### Exemple 27

 ```text
 range
@@ -95,25 +243,25 @@ range
    [::step(step)]
 ```

-### Exemple 12
+### Exemple 28

 ```text
 (250u8..255u8)::step(2u8)
 ```

-### Exemple 13
+### Exemple 29

 ```text
 250 252 254
 ```

-### Exemple 14
+### Exemple 30

 ```text
 (1..10)::step(4)
 ```

-### Exemple 15
+### Exemple 31

 ```text
 1 5 9
@@ -121,4 +269,4 @@ range

 ## 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.
--- a/examples/037-dependances-et-scopes-examples.md
+++ b/examples/037-dependances-et-scopes-examples.md
@@ -1,8 +1,8 @@
 # Exemples / DO-DON'T — Chapitre 37 — Dépendances 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

@@ -255,6 +255,18 @@ import type namespace.Type
    as LocalType;
 ```

+### Exemple 30
+
+```text
+MapDB-like
+RocksDB-like
+PostgreSQL-compatible components
+SDL-like multimedia
+WebKit/WebView integrations ou remplacements
+bibliothèques image/audio/vidéo
+outils UI et multimedia
+```
+
 ## 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.
--- a/examples/048-inventaire-des-points-v1-encore-ouverts-examples.md
+++ b/examples/048-inventaire-des-points-v1-encore-ouverts-examples.md
@@ -4,7 +4,7 @@

 ## Exemples extraits du chapitre

-Aucun bloc d'exemple explicite dans cette révision.
+Aucun bloc d’exemple explicite dans cette révision.

 ## DO / DON'T / WHY / compiler error / edge cases

--- a/examples/051-invariants-de-conception-examples.md
+++ b/examples/051-invariants-de-conception-examples.md
@@ -4,7 +4,7 @@

 ## Exemples extraits du chapitre

-Aucun bloc d'exemple explicite dans cette révision.
+Aucun bloc d’exemple explicite dans cette révision.

 ## DO / DON'T / WHY / compiler error / edge cases