Fonctions

Tu as déjà croisé des fonctions dans le module précédent sans t'y attarder — il est temps de les regarder en détail. Une fonction Verse regroupe un calcul réutilisable derrière un nom : au lieu de recopier la même formule de dégâts à dix endroits, tu l'écris une fois et tu l'appelles partout où tu en as besoin.

Anatomie d'une déclaration

Double(X : int) : int =
    X * 2

• Double : le nom de la fonction, en PascalCase.
• (X : int) : la liste des paramètres — ici un seul, nommé X, de type int. Chaque paramètre a obligatoirement un type déclaré.
• : int après la parenthèse fermante : le type de la valeur renvoyée.
• Le corps, après = : soit une seule expression sur la même ligne (comme ici), soit un bloc indenté de plusieurs lignes.

Corps sur plusieurs lignes

Quand le calcul demande une étape intermédiaire, le corps devient un bloc indenté, et la dernière expression évaluée est automatiquement la valeur renvoyée — pas besoin de return explicite, même si le mot-clé existe et reste utile pour sortir plus tôt d'une fonction (tu le recroiseras au module 3, dédié au contrôle de flux) :

Triple(X : int) : int =
    Y : int = X * 3
    Y

Une fonction peut en appeler une autre

Comme dans n'importe quel langage, une fonction Verse peut appeler une autre fonction définie dans le même fichier. C'est ce qui permet de découper un calcul complexe en petites briques testables séparément :

ComboBonus(Combo : int) : int =
    Combo * 5

DamageWithCombo(BaseDamage : int, Combo : int) : int =
    BaseDamage + ComboBonus(Combo)

DamageWithCombo ne recalcule rien elle-même pour le bonus : elle délègue à ComboBonus et additionne le résultat. C'est la même logique que découper un problème en sous-problèmes plus simples, une compétence que tu utiliseras constamment dans la banque de problèmes libre.

Fonctions pures d'abord

Toutes les fonctions de ce module ont un point commun : elles ne dépendent que de leurs paramètres et ne modifient rien en dehors d'elles-mêmes — on parle de fonctions pures. Elles sont plus simples à tester (mêmes entrées, toujours la même sortie) et plus simples à corriger automatiquement, ce qui explique pourquoi la banque de problèmes et ce parcours s'appuient dessus en priorité. Les fonctions qui modifient un état extérieur (une méthode qui change un champ d'objet, par exemple) arriveront avec les classes et structs, au module 7.

Ce que tu vas pratiquer

Les exercices combinent tout ce que tu as vu jusqu'ici : plusieurs paramètres typés, un corps multi-lignes avec une variable intermédiaire, et un appel d'une fonction vers une autre. Rien de nouveau côté variables — l'objectif est de prendre l'habitude de découper un calcul en fonctions plutôt que d'écrire un seul gros bloc.

Contenu à valider manuellement dans un vrai environnement UEFN avant publication définitive (voir SPEC.md §7 — fidélité sémantique).