Re: Fin de solution.

Pour appuyer ta réponse, j'ajouterai que l'inférence de type se fait sur les signatures, pas sur l'implémentation de celles-ci.

Donc quand tu as :

module type Ai =
 sig
 type a
 type b
 val f : b -> a
 end

L'implémentation de a et b est masquée, et leur type n'est pas déterminé; il s'agit d'un nouveau type que tu viens de créer, et non pas une appellation différente d'un type existant.

C'est utile si tu veux masquer l'implémentation d'un type. Par exemple, ton set a pour type t et tu n'as pas à savoir comment il est implémenté dans ton module. Tu n'as pas besoin de savoir que t est implémenté comme suit :

 type 'a set =
 | Empty
 | Node of 'a set * 'a * 'a set * int

et le compilateur tu génèrera une erreur si tu passes ton tupple là où il fallait passer le type de ton set.

Donc : utiliser les type de module c'est bien, ça permet de créer des foncteurs partageant les même types, et simplifier la documentation. Par contre, réduire une module à un type, c'est mal, ça casse l'inférence de type, il vaut mieux laisser le compilateur inférer pour toi les types de ton module.