Curryfication : ce que dit la flèche

let ajoute x y = x + y
let ajoute_paire (x, y) = x + y
let ajoute3 = ajoute 3
let applique_deux f x = f (f x)

val ajoute : int -> int -> int
val ajoute_paire : int * int -> int
val ajoute3 : int -> int
val applique_deux : ('a -> 'a) -> 'a -> 'a

et applique_deux ajoute3 0 vaut $6$.

La flèche associe à droite. int -> int -> int se lit int -> (int -> int) : ajoute n'est pas une fonction de deux arguments, c'est une fonction d'un argument qui rend une fonction. C'est la curryfication. L'appel ajoute 3 4 s'analyse en (ajoute 3) 4 : on applique ajoute à $3$, ce qui produit une fonction, puis on applique celle-ci à $4$.

D'où l'application partielle, gratuite : ajoute 3 est une valeur parfaitement ordinaire, de type int -> int, qu'on peut nommer, ranger dans une liste, ou passer à une autre fonction.

ajoute_paire n'a rien de tel. Son type int <em> int -&gt; int dit qu'elle prend un* argument, qui est un couple. ajoute_paire 3 ne compile pas :

Error: The constant 3 has type int but an expression was expected of type
         int * int

Les deux écritures ne diffèrent que d'une paire de parenthèses et d'une virgule, et elles décrivent deux objets différents. La forme curryfiée est celle qu'on écrit par défaut.

Fonction d'ordre supérieur. applique_deux reçoit une fonction en argument : c'est ce qu'on appelle une fonction d'ordre supérieur. Son type ('a -> 'a) -> 'a -> 'a le dit sans commentaire — le premier argument doit avoir une source et un but identiques, sans quoi f (f x) n'aurait pas de sens. Le compilateur a déduit cette contrainte de la seule écriture f (f x).

Toutes les fonctions du module List citées par l'annexe — map, filter, exists, for_all, iter — sont d'ordre supérieur : c'est ce qui permet d'écrire une fois le parcours et de faire varier le traitement.