154 lines
4.2 KiB
Markdown
154 lines
4.2 KiB
Markdown
# 15. Fonctions, méthodes et `clsmethod`
|
|
|
|
## 15.1 Catégories — V1 REQUIS — FIGÉ
|
|
|
|
```text
|
|
func fonction libre
|
|
method méthode d'instance
|
|
clsmethod méthode de classe
|
|
operator implémentation d'un contrat opérateur
|
|
```
|
|
|
|
## 15.2 Retours directs, `Result`, `throws` et `faults` — V1 REQUIS — FIGÉ
|
|
|
|
Le type de retour et le mécanisme d'échec sont des dimensions distinctes.
|
|
|
|
Une callable peut retourner directement `T` même si elle peut produire une `Exception` checked ou un `Fault` unchecked :
|
|
|
|
```text
|
|
func readConfig(String path) -> Config
|
|
throws IOException
|
|
|
|
method elementAt(uint64 index) -> T
|
|
faults IndexOutOfBoundsFault
|
|
```
|
|
|
|
`Result<T,E>` est utilisé lorsque l'échec doit être transporté explicitement comme une valeur et inspecté par l'appelant :
|
|
|
|
```text
|
|
func parseExternalInput(String input) -> Result<Value, ParseError>
|
|
```
|
|
|
|
Les combinaisons sont indépendantes :
|
|
|
|
```text
|
|
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.
|
|
|
|
```text
|
|
return value;
|
|
return Result::Ok(value);
|
|
return Result::Ok(Void);
|
|
```
|
|
|
|
`return` quitte la fonction/méthode.
|
|
|
|
## 15.4 Surcharge — V1 REQUIS — FIGÉ
|
|
|
|
Surcharge autorisée pour fonctions et méthodes.
|
|
|
|
La signature ne contient pas le type de retour.
|
|
|
|
Il ne peut donc pas exister deux overloads distingués uniquement par leur retour.
|
|
|
|
## 15.5 Résolution de surcharge — V1 REQUIS — À FINALISER
|
|
|
|
Les règles exactes de préférence entre exact match, conversions explicites/contextuelles, generics et variadiques doivent être figées.
|
|
|
|
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.
|
|
|
|
---
|