v0.2.18

examples/004-couches-de-lecosysteme-v1-examples.md

@@ -90,3 +90,10 @@ saselang/mapdb*
 ## 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.
+
+### Exemple — contrat Core, implémentation SDK
+
+```text
+Core: Hashable, Hasher, interfaces de collections, Slice<T>
+SDK : Vector<T>, HashSet<T>, HashMap<K,V>, implémentations concrètes de Hasher
+```

examples/005-types-primitifs-examples.md

@@ -153,3 +153,13 @@ where T implements Numeric
 ## 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.
+
+### Exemple — égalité flottante IEEE adoptée
+
+```text
+NaN == NaN       // false
++0.0 == -0.0     // true
+```
+
+La révision 0.2.18 référence IEEE 754-2019 ; une révision future du standard n'altère pas rétroactivement cette version de Saselang.
+

examples/008-classes-et-object-examples.md

@@ -46,9 +46,19 @@ super::method()
 ### Exemple 6
 
 ```text
-Object::sameInstance(Object other) -> bool
+const method sameIdentity(const Object other) -> bool
 ```
 
 ## 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.
+
+### Exemple 7 — égalité logique vs identité
+
+```text
+User a = ...;
+User b = ...;
+
+a == b;                 // égalité logique si User la définit
+a::sameIdentity(b);      // identité exacte de référence
+```

examples/020-operateurs-examples.md

@@ -72,6 +72,7 @@ a ^ b
 ```text
 OpPartialEqual<Lhs,Rhs>
 OpEqual<T>
+Equatable<T>
 ```
 
 ### Exemple 9
@@ -241,3 +242,21 @@ a < b && b < c
 ## 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.
+
+### Exemple 29 — `Equatable<T>` ne duplique pas `==`
+
+```text
+interface Equatable<T> extends OpEqual<T> {
+}
+```
+
+`Equatable<T>` sert de contrainte sémantique aux APIs génériques ; l'implémentation opérateur reste `OpEqual<T>`.
+
+### Exemple 30 — floats
+
+```text
+NaN == NaN       // false selon IEEE
++0.0 == -0.0     // true selon IEEE
+```
+
+Les `float*` bruts ne satisfont donc pas directement `Equatable<float*>`.

examples/022-collections-et-iteration-examples.md

@@ -196,7 +196,7 @@ map[key] -> V                    // strict
 map::get(key) -> Option<V>       // conditionnel
 map[key] = value                 // remplacement seulement
 map::insert(key, value)          // clé nouvelle, DuplicateKeyFault sinon
-map::remove(key)                 // clé existante, KeyNotFoundFault sinon
+map::remove(key) -> V            // clé existante, KeyNotFoundFault sinon
 map::clear() -> uint64
 ```
 
@@ -344,4 +344,4 @@ range
 
 ## 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.
+À consolider progressivement avant la baseline publique V3 et à transformer, lorsque pertinent, en tests de conformité de la toolchain.\n\n## Exemples 0.2.18 — Vector / Slice / hashing\n\n### Vector 1 — backing stable et slices\n\n```text\nVector<int32> values = Vector<int32>::builder()\n    ::append(10)\n    ::append(20)\n    ::append(30)\n    ::build();\n\nSlice<int32> part = values::slice(0..<2);\n\nvalues::reserve(1000); // part reste valide\nvalues::append(40);     // part reste valide\nvalues[0] = 11;         // part reste valide et observe 11\n\nvalues::insert(0, 5);  // part devient invalide en V1\npart[0];                // SliceInvalidatedFault\n```\n\n### Vector 2 — API structurelle\n\n```text\nvalues::append(value);             // -> Void\nvalues::insert(index, value);      // index <= length()\nT removed = values::removeAt(index);\nuint64 removedCount = values::clear();\n```\n\n### DON'T — literal de Vector\n\n```text\nVector<int32> values = [1, 2, 3]; // ERROR\n```\n\n### DO — builder explicite\n\n```text\nVector<int32> values = Vector<int32>::builder()\n    ::append(1)\n    ::append(2)\n    ::append(3)\n    ::build();\n```\n\n### Hash 1 — contrats Core\n\n```text\ninterface Equatable<T> extends OpEqual<T> {\n}\n\ninterface Hashable {\n    const method hash(Hasher hasher) -> Void;\n}\n\ninterface Hasher {\n    method writeBytes(const Slice<uint8> bytes) -> Void;\n    const method finish() -> uint64;\n}\n```\n\n### Hash 2 — clé stable\n\n```text\nclass UserKey implements Equatable<UserKey>, Hashable {\n    const uint64 id;\n    String label;\n\n    // == et hash reposent uniquement sur id.\n    // label peut changer sans modifier l'identité hashable.\n}\n```\n\n### DON'T — identité hashable mutable\n\n```text\nclass BadKey implements Equatable<BadKey>, Hashable {\n    String name;\n\n    // DON'T si == et hash dépendent de name et que name peut changer.\n}\n```\n\n### HashSet / HashMap\n\n```text\nHashSet<T>\n    where T implements Equatable<T>\n    where T implements Hashable\n\nHashMap<K,V>\n    where K implements Equatable<K>\n    where K implements Hashable\n```\n\nL'ordre d'itération n'est pas garanti. Une collision de hash n'est pas une erreur ; l'égalité distingue les valeurs.\n\n### HashMapBuilder — doublons stricts\n\n```text\nHashMap<String,int32> values = HashMap<String,int32>::builder()\n    ::insert("one", 1)\n    ::insert("two", 2)\n    ::build();\n\nHashMap<String,int32>::builder()\n    ::insert("one", 1)\n    ::insert("one", 2); // DuplicateKeyFault\n```\n

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

@@ -64,3 +64,13 @@ function pointer
 ```
 
 Les pointeurs explicites restent un sous-modèle mémoire dédié et ne remplacent pas les références/slices sûres dans le code ordinaire.
+
+### Exemple — backing storage stable
+
+```text
+Vector<int32> values = ...;
+Slice<int32> part = values::slice(0..<2);
+
+values::reserve(1024); // une éventuelle relocalisation physique reste invisible
+part[0];               // toujours valide
+```