L'idée est en parallèle, d'ajouter un argument dico en première position à toutes les fonctions, tout en complétant son type. On arrive ainsi par exemple au dictionnaire des flottants suivant :
| (* Types des coefficients *) type 'a dico = {zero: 'a ; un : 'a ; is_zero : 'a -> bool ; plus : 'a -> 'a -> 'a ; n_plus : int -> 'a -> 'a ; mult : 'a -> 'a -> 'a ; print : 'a -> unit} ;; (* Qui sont ici des flottants *) let dico_float = {zero=0.0 ; un=1.0 ; is_zero=(fun x -> x = 0.0) ; plus=(fun x y -> x +. y) ; n_plus=(fun n x -> float_of_int n *. x) ; (* itérer plus n fois *) mult=(fun x y -> x *. y) ; print=print_float} ;; |
Le code complet est gsol.ml. À titre d'exemple voici la nouvelle fonction somme :
| let rec somme dico p1 p2 = match p1,p2 with | [],_ -> p2 | _,[] -> p1 | ({degre=d1} as m1)::r1, ({degre=d2} as m2)::r2 -> if d1 > d2 then m1::somme dico r1 p2 else if d1 < d2 then m2::somme dico p1 r2 else (* d1 = d2 *) let c = dico. plus m1.coeff m2.coeff in if dico.is_zero c then somme dico r1 r2 else {coeff=c ; degre=d1}::somme dico r1 r2 ;; |
Du point de vue Caml, on remarque que le cycle modifier, compiler,… recommencer, converge assez vite. Le procédé du dictionnaire passé en argument n'est pas très idiomatique, on aurait ici plutôt recours à un foncteur, qui est en quelque sorte une fonction des modules dans les modules. C'est l'esprit du dernier exercice du cours.