L'idée est d'ajouter un argument dico en première position à toutes les fonctions, tout en complétant son type. On arrive ainsi au type dico et à la valeur dico_float suivants :

(* 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 plutôt ici recours à un foncteur, qui est en quelque sorte une fonction des modules dans les modules. C'est l'esprit du dernier exercice du cours.