v0.2.17

chapters/015-fonctions-methodes-et-clsmethod.md

@@ -9,37 +9,42 @@ clsmethod  méthode de classe
 operator   implémentation d'un contrat opérateur
 ```
 
-## 15.2 Retours directs et `Result` — V1 REQUIS — FIGÉ
+## 15.2 Retours directs, `Result`, `throws` et `faults` — V1 REQUIS — FIGÉ
 
-L'ancienne règle « toute fonction/méthode retourne `Result` » est supprimée.
+Le type de retour et le mécanisme d'échec sont des dimensions distinctes.
 
-Règle V1 :
+Une callable peut retourner directement `T` même si elle peut produire une `Exception` checked ou un `Fault` unchecked :
 
 ```text
-opération infaillible
-    -> retourne directement T
+func readConfig(String path) -> Config
+    throws IOException
 
-opération pouvant produire une erreur récupérable
-    -> retourne Result<T>
-       ou Result<T,E>
+method elementAt(uint64 index) -> T
+    faults IndexOutOfBoundsFault
 ```
 
-Exemples infaillibles :
+`Result<T,E>` est utilisé lorsque l'échec doit être transporté explicitement comme une valeur et inspecté par l'appelant :
 
 ```text
-method length() -> uint64
-method containsKey(K key) -> bool
-Object::sameInstance(Object other) -> bool
-func min(int32 a, int32 b) -> int32
+func parseExternalInput(String input) -> Result<Value, ParseError>
 ```
 
-Exemples faillibles :
+Les combinaisons sont indépendantes :
 
 ```text
-func readFile(String path) -> Result<String, IoError>
-method parse(String input) -> Result<Value, ParseError>
+T
+T throws SomeException
+T faults SomeFault
+T throws SomeException faults SomeFault
+Result<T,E>
+Result<T,E> throws SomeException
+Result<T,E> faults SomeFault
 ```
 
+Saselang ne force donc plus une callable à retourner `Result` uniquement parce qu'elle peut échouer. À l'inverse, une API ne doit pas remplacer systématiquement un échec normal du domaine par un `Fault` si `Option` ou `Result` exprime mieux le contrat.
+
+Le Core ne crée pas mécaniquement des paires `op()` / `tryOp()` ayant pour seule différence « valeur directe avec fault » versus « même opération dans Result ». Deux opérations distinctes doivent porter des sémantiques réellement distinctes.
+
 ## 15.3 Retour explicite — V1 REQUIS — FIGÉ
 
 Pas de retour implicite de dernière expression.