# Changelog documentaire — 0.2.18

## 0.2.18

- `Vector<T>` fermé comme `ResizableList<T>` contigu à longueur runtime dynamique, avec `append`, `insert`, `removeAt`, `clear`, `capacity`, `reserve` et `slice` ;
- `Vector::append(T) -> Void` figé ; `insert(index,value)` accepte `0 <= index <= length()` et produit `IndexOutOfBoundsFault` au-delà ;
- `Vector::removeAt(index) -> T` figé avec `IndexOutOfBoundsFault` pour un index invalide ;
- garanties de complexité de `Vector` figées : indexation O(1), cardinalité O(1), append O(1) amorti, insert/removeAt O(n), slice O(1), capacity O(1), reserve O(n) au pire ;
- aucun `reserveExact`, `resize` implicite ni opération générale de shrink dans le contrat standard de `Vector` ;
- construction dynamique explicite par class methods/factories et `VectorBuilder<T>` ; le littéral `[...]` reste réservé aux arrays contextualisés ;
- backing storage stable retenu dès V1 pour `Vector`/`Slice` : une relocalisation physique, `reserve`, un remplacement d’élément ou `append` ne rendent pas les slices existantes invalides ;
- en V1, `insert`, `removeAt` et un `clear` effectif invalident toutes les slices dérivées du vector ; un accès ultérieur produit `SliceInvalidatedFault` ;
- `Equatable<T>` introduit comme capacité Core réutilisant le contrat opérateur canonique `OpEqual<T>` sans seconde implémentation de l’égalité ;
- `Object::sameInstance(...)` renommé en `Object::sameIdentity(...)` pour distinguer explicitement identité de référence et égalité logique ;
- `Hashable` fixé dans le Core avec stabilité normative de l’identité hashable pendant toute la durée de vie de la valeur ;
- `Hasher` fixé dans le Core ; ses implémentations concrètes restent des implémentations SDK/runtime ;
- contrat minimal `Hasher::writeBytes(const Slice<uint8>)` + `finish() -> uint64`, avec framing canonique Core des valeurs fondamentales et `finish()` non mutateur ;
- `HashSet<T>` et `HashMap<K,V>` fermés comme implémentations SDK non ordonnées exigeant respectivement `T` ou `K` `Equatable + Hashable` ;
- collisions de hash définies comme normales et résolues par l’égalité ; aucune `HashCollisionFault` ;
- hasher/seed internes des collections hashées non contractuels et potentiellement différents entre instances ; ordre d’itération non stable/non garanti ;
- `ResizableMap::remove(key)` retourne désormais `V` et reste strict avec `KeyNotFoundFault` ;
- builders `Vector`, `HashSet` et `HashMap` mutables, chaînables, non consommés par `build()` et produisant des résultats sémantiquement indépendants ;
- un doublon dans `HashSetBuilder` suit la sémantique idempotente du set ; une clé dupliquée dans `HashMapBuilder` produit `DuplicateKeyFault` ;
- la sémantique flottante de cette révision référence explicitement IEEE 754-2019, standard actif au moment de la révision ; une future norme finale devra être adoptée explicitement par une révision de Saselang.

## 0.2.17

- hiérarchie `Error` étendue à trois branches sœurs : `ResultError`, `Exception`, `Fault` ;
- `Exception` reste checked via `throw` / `throws`, tandis que `Fault` est unchecked, capturable et documentable par `faults` ;
- ajout du statement `fault` réservé aux descendants de `Fault` ;
- `catch` limité aux branches `Exception` et `Fault`, jamais `Error` ou `ResultError` ;
- `faults` défini comme clause optionnelle, non exhaustive et sans propagation obligatoire ;
- `throws` rendu indépendant du type de retour : une callable retournant directement `T` peut déclarer des exceptions checked ;
- suppression du principe « toute opération faillible doit retourner `Result` » ; `Result` reste réservé aux échecs explicitement transportés comme valeurs ;
- suppression des duplications automatiques `op()` / `tryOp()` lorsqu'elles ne diffèrent que par le canal d'échec ;
- conversions numériques canoniques migrées vers valeur directe + `NumericConversionFault` ;
- `NumericConversionError` remplacé par `NumericConversionFault`, avec `NotFinite`, `NotIntegral`, `OutOfRange`, `Inexact` ;
- conversions Unicode invalidables migrées vers valeur directe + `UnicodeEncodingFault`, sans familles `tryFrom`/`tryTo` parallèles mécaniques ;
- `PartialOrdering` séparé de `Ordering`; `Ordering` contient uniquement `Less`, `Equal`, `Greater` ;
- `Comparable<T>` et `Comparator<T>` retenus pour l'ordre naturel/principal et l'ordre externe ; un comparator explicite gagne toujours ;
- `Iterable<T>::iterator()` et `Iterator<T>::next() -> Option<T>` figés ; `Iterator<T>` reste distinct d'`Iterable<T>` ;
- ajout de `View<T> extends Iterable<T>` avec `count()` / `isEmpty()` et sans `contains()` obligatoire ;
- `Set<T>` / `ResizableSet<T>` fermés, avec `clear() -> uint64` ;
- `Map<K,V>` n'est pas directement `Iterable`; `keys()` / `values()` / `entries()` retournent des vues ;
- indexation map stricte `map[key] -> V`, `get(key) -> Option<V>`, affectation indexée limitée au remplacement d'une clé existante ;
- `ResizableMap` utilise `insert`, `remove`, `clear`, avec faults stricts au lieu de variantes `tryInsert` / `tryRemove` mécaniques ;
- `MapEntry<K,V>` reste une valeur de lecture et non un proxy mutable vers la map ;
- `SortedSet<T>`, `SortedMap<K,V>`, `TreeSet<T>` et `TreeMap<K,V>` définis en principe ; création par factories `natural()` / `withComparator()` ;
- les garanties concurrentes de collections restent orthogonales et relèvent du SDK (`ConcurrentMap`, etc.) sans symétrie artificielle ;
- le chapitre mémoire identifie désormais explicitement le sous-modèle pointeurs : références de classe, slices, pointeurs Saselang, raw/FFI et function pointers.

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

- 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

- fermeture du socle generics V1 : syntaxe, inférence d'appel, contraintes nominales, invariance, absence de CTAD/wildcards/spécialisation ;
- `Numeric` retenu comme vraie abstraction Core utilisable dans les contraintes génériques ;
- const generics V1 limités aux types de paramètres `bool`, `char`, `uint8..uint256` et enums simples sans payload ;
- arguments const generic volontairement boring : aucune callable directement dans `<...>` ; calcul complexe matérialisé d'abord dans une `const` ;
- inférence const generic structurelle uniquement, sans solveur algébrique ;
- récursivité générique régulière autorisée ; auto-référence transformante et polymorphic recursion interdites V1 ;
- toute récursivité by-value interdite, y compris via une instanciation de taille théoriquement nulle ;
- cycles d'héritage interdits, diamants non cycliques autorisés ;
- classes récursives autorisées via leurs références d'objet ;
- distinction nominalement connu / sémantiquement complet / layout-complet et suppression du besoin de forward declarations utilisateur ;
- imports explicites requis même entre deux types du même namespace ; les imports sont déclaratifs, non exécutables, et leurs cycles sont autorisés ;
- `NaN`, infinities et zéros signés stabilisés pour `float -> float` ;
- `NumericConversionError` stabilisé conceptuellement autour de `NotFinite`, `NotIntegral`, `OutOfRange`, `Inexact` ;
- matrice `float -> integer` réduite par paire selon la règle anti-doublon ;
- conversions fondamentales Core obligatoires pour toute paire de types supportés, avec émulation logicielle lorsque raisonnable ;
- nomenclature de capabilities organisée par propriétaires `language.*`, `core.*`, `target.*`, `platform.*`, `sdk.*` ;
- V1/V2 explicitement positionnées comme bases/POC, V3 comme première baseline publique de stabilité.


## 0.2.13

- règle générale de composition Core figée : aucune méthode combinée lorsqu'une chaîne d'opérations existantes exprime exactement la même sémantique ;
- suppression conceptuelle des alias `tryFloorTo...`, `tryCeilTo...`, `tryRoundTo...` et `tryTruncateTo...` ;
- `float -> integer` réduit aux familles `tryTo...`, `trySaturateTo...` et `tryWrapTo...`, composables avec `floor()`, `ceil()`, `round()` et `truncate()` ;
- maintien des méthodes combinées uniquement lorsqu'une composition changerait le contrat ou perdrait l'information nécessaire ;
- `saturatingRoundToFloatXX()` reste justifié pour les conversions flottantes où arrondi et saturation ne peuvent pas être séparés sans changer la sémantique.

## 0.2.12

- migration de la Bible monolithique vers une distribution multifichier ;
- ajout d'un fichier compagnon examples / DO-DON'T par chapitre ;
- ajout des vues Language/Compiler, Language+Core et Platform ;
- ajout de l'annexe exhaustive des conversions numériques ;
- `is` figé comme test d'appartenance à une hiérarchie polymorphe ;
- `instanceof` figé comme test de classe runtime exacte, limité aux classes concrètes non abstraites ;
- upcast par assignabilité ; downcast canonique par `is` + refinement ;
- conversions numériques exposées par le Core plutôt que multipliées comme syntaxe compiler-specific ;
- `NumericConversionError` retenu comme nom de travail ;
- règle de non-redondance des variantes de conversion ;
- nom `saturatingRoundToFloatXX()` retenu lorsqu'arrondi et saturation doivent tous deux être annoncés ;
- modèle de livraison documentaire `full` + deltas SemVer.