# 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 et `Result` — V1 REQUIS — FIGÉ

L'ancienne règle « toute fonction/méthode retourne `Result` » est supprimée.

Règle V1 :

```text
opération infaillible
    -> retourne directement T

opération pouvant produire une erreur récupérable
    -> retourne Result<T>
       ou Result<T,E>
```

Exemples infaillibles :

```text
method length() -> uint64
method containsKey(K key) -> bool
Object::sameInstance(Object other) -> bool
func min(int32 a, int32 b) -> int32
```

Exemples faillibles :

```text
func readFile(String path) -> Result<String, IoError>
method parse(String input) -> Result<Value, ParseError>
```

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

---