foncteurs et polymoprhisme

Emmanuel Engel (Emmanuel.Engel@lri.fr)
Fri, 27 Jun 1997 14:48:25 +0200

Date: Fri, 27 Jun 1997 14:48:25 +0200
From: Emmanuel Engel <Emmanuel.Engel@lri.fr>
To: caml-list@inria.fr
Subject: foncteurs et polymoprhisme

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