Expression dont tous les composants ont un type connu

leur,

– L’expression est un identificateur li´e dans le contexte : son type est celui indiqu´e dans la premi`ere liaison de cet identificateur trouv´ee dans le contexte,

– L’expression est une application de fonction : soit f e1 e2 ...ep une

expression, o`ufest une expression de type t₁-> t₂-> . . . -> t_n-> t_res, e₁ une expression de type t1, . . . ,ep une expression de type tp, et p ≤ n.

Alors, l’expression f e1 e2 ...ep est de type tp+1->. . . -> tn -> tres.

– L’expression est conditionnelle : if expr then e1 else e2; si expr a le type bool´een et les deux expressions e1 et e2 ont le mˆeme type t alors l’expression a le type t

– dans les autres cas, il y a erreur de typage (signal´ee par le compilateur) Exemples La fonctionchar for read : char ->stringest pr´ed´efinie et trans- forme un caract`ere en la chaˆıne constitu´ee de ce caract`ere. L’expressionchar for read ‘a‘ est l’application de l’expression char for read de type char ->string `a l’expression ‘a‘, de typechar. Elle est donc de typestring:

# char for read ‘a‘ ;;

-:string = ”a”

Nous avons d´ej`a rencontr´e, au chapitre pr´ec´edent, les deux fonctions pr´ed´efinies string length: string ->intet nth char: string ->int ->char.

D´eterminons le type de l’expression

let ch="azerty" in char for read (nth char ch (string length ch -1)). Elle est de la forme

let ch = "azerty" in e1, avec e1 = char for read e2, e2 = nth char e3 e4, e3 = ch,

e4=string length e3 -1.

Commechest li´e `a la valeur "azerty", on a :

e3 : string puisstring length : string ->int, e3 : string d’o`u e4 = string length e3 - 1 : int; comme

nth char: string ->int ->char, e3: string, e4: inton ae2 = nth char e3 e4 : char; enfin, comme

# let ch="azerty" in char for read(nth char ch (string length ch -1)) ;;

-:string : ”y”

5.2.2 Typage d’une valeur fonctionnelle : synth`ese de type Lorsqu’on exprime une valeur fonctionnelle, l’expression fournie `a la ma- chine n’indique nulle part quel est le type des arguments ni le type du r´esultat de la fonction. Le m´ecanisme d´ecrit `a la section pr´ec´edente ne s’applique donc plus, puisque certains composants de l’expression, `a savoir les identificateurs d’arguments formels, ont un type a priori inconnu. Dans ce cas, c’est la ma- chine CAML qui d´etermine le type de la valeur fonctionnelle ainsi exprim´ee.

Consid´erons par exemple l’expression de d´efinition de la fonction max2, donn´ee au chapitre pr´ec´edent :

let max2 x y = if x>=.y then x else y ;;

La phrase de d´efinition ne comporte aucune indication explicite sur le type des deux arguments, ni sur celui du r´esultat. Or la machine nous fournit le type fonctionnel demax2 dans sa r´eponse, en l’occurrence le fait que les deux arguments doivent ˆetre de typefloatet que le r´esultat est de type float. La machine CAML a donc effectu´e un calcul de type, appel´e encore synth`ese de

type.

Sans entrer dans les d´etails, indiquons que l’algorithme de synth`ese de type utilis´e par la machine est bas´e sur les r`egles de typage vues `a la section pr´ec´edente. C’est `a partir de l’expression de d´efinition et des informations de types d´ej`a pr´esentes dans le contexte que la machine CAML essaye de d´eterminer le type que doit avoir chaque argument formel pour que cette ex- pression soit coh´erente. L’expression de d´efinition de la fonctionmax2contient les deux identificateursxety, li´es aux deux arguments formels et dont le type est a priori inconnu; l’expression contient aussi la valeur fonctionnelle >=., connue de la machine CAML comme op´erateur infixe s’appliquant `a deux argu- ments de typefloat. Par cons´equent, la coh´erence de l’expression de d´efinition contraintx et y `a ˆetre de type float. De plus, cette contrainte n’est contre- dite par aucune autre dans l’expression de d´efinition. Enfin, le r´esultat de la fonction ´etant soit x soit y, il n’y a pas de conflit puisque tous deux sont de mˆeme type (float). Ainsi, la machine peut conclure et fournir sa r´eponse :

max2: float ->float ->float = <fun>

Donnons d’autres exemples. La fonction pr´ed´efinie

string length: string ->int d´elivre la longueur de son argument, et la fonction pr´ed´efinie

nth char: string ->int ->char est telle que nth char ch n = caract`ere de rangnde la chaˆıne ch(le premier est de rang 0) :

5.2. Typage des expressions 53 # string length "bonjour" ;;

- : int = 7

# nth char "bonjour" 1 ;;

- : char = ‘o‘

(les deux identificateursstring lengthet nth charsont automatiquement in- troduits dans le contexte `a l’ouverture d’une session).

D´efinissons une fonction qui d´elivre le dernier caract`ere d’une chaˆıne non vide. Puisque le premier caract`ere est de rang 0, le dernier est de rang l-1, o`u l est la longueur de la chaˆıne. La premi`ere version donn´ee ci-dessous ne fait aucun test sur la vacuit´e de la chaˆıne, cette pr´econdition ´etant suppos´ee v´erifi´ee.

# let dernier ch = nth char ch (string length ch -1) ;;

dernier:string -> char = <fun>

D´etaillons le calcul des types. La valeur dernier est suivie d’un argument formel, elle est donc de typeX ->Y, o`uXetYsont des inconnues de types. Les ´equations suivantes doivent ˆetre v´erifi´ees :

(1) ch : X

(2) nth char ch (string length ch -1) : Y

Examen de l’expression de d´efinition: le contexte indique nth char: string ->int ->char. L’identificateur nth char est suivi de l’expression r´eduite `a l’identificateur ch, puis de l’expression string length ch -1. Par cons´equent, la coh´erence de l’expression n’est possible que si les deux ´equations suivantes sont v´erifi´ees :

(3) ch : string

(4) string length ch -1 : int

(1) et (3) impliquentX = string. De plus, le contexte indiquestring length : string ->intce qui, avec l’´equation (3) impliquestring length ch : intd’o`u string length ch -1 : int; l’´equation (4) est donc v´erifi´ee. Reportant ces in- formations dans l’´equation (2), on trouve quenth char ch (string length ch -1) : char =Y. La d´etermination des typesXetYest donc possible et compl`ete, d’o`u la r´eponse de la machine : dernier : string ->char .