foncteurs et polymoprhisme

[Emmanuel Engel <Emmanuel.Engel@lri.fr>]

Il m'arrive souvent de vouloir definir des types de la forme

type expr =
   AC of Exprset.t
 | A of exp list 
 | .....


module Exprset = Set.make(struct type t = expr let compare = compare
end)

(en camllight, 
  type expr =	
    AC of expr set__t
   |A of expr list
   |....
)

cela n'est pas facilement possible en ocaml, les definitions incluant 
des modules ne peuvent etre ( mutuellement ) recursives.

Une methode possible est la traduction en ocaml de la solution
camllight:

type expr =
  AC of expr GeneriqueSet.t 
 |A of  expr list 
 |...                  

et definir des ensembles generiques.

Question:
    Existe-t-il un moyen simple et rapide a l'aide du foncteur 
  Set.Make de creer des ensembles polymorphes qui utilisent une
  fonction de comparaison generique (Pervasives.compare par exemple) ??

  eg 

  module GeneriqueSet = Set.Make(struct ?????? end)

Il me semble que non et, que cette impossibilite est plus due a la facon 
dont est declare le foncteur qui permet de construire les ensembles qu'a 
une vraie limite du systeme; voici une version legerement differente de
ce foncteur qui me permet une telle manip:

module Make(S:sig type 'a t val compare : 'a t -> 'a t -> int end)=
  (struct
     type 'a elt = 'a  S.t
     type 'a set = ('a elt) list
     let empty = []
     and mem = List.mem
     and add e s = e::s
  end:sig
	type 'a elt = 'a S.t
        and 'a set
        val empty : 'a set
        val mem : 'a elt -> 'a set -> bool
        val add : 'a elt -> 'a set -> 'a set
      end);;


module IntSet = Make(struct type 'a t = int let compare = (compare:int
-> int -> int) end);;
module GenericSet = Make(struct type 'a t = 'a let compare = compare
end);;




Commentaires ??


-- 

- Emmanuel Engel