On Sun, 27 May 2001, Tom _ wrote:

> > You can do this now if you make a PolySet module by
> > copying the
> > "monomorphic" implementation from the stdlib,
> > changing elt and t to 
> > 'a elt and 'a t and, using that instead of Set,
> > something like:
> > 
> > let f (cmp : 'a -> 'a -> bool) =
> >   let module SomeSet =
> >     PolySet.Make 
> >       (struct type 'a t = 'a let compare =
> > Pervasives.compare end) in
> >   ()
> 
> Thanks; that's very useful to know, and it seems
> to be working.  I think it might be useful to feature
> the ability to have polymorphic types in modules
> a little more prominently in the documentation.

Yes, or you have to make a habit of reading lots of the posts from
yesteryear in the mailing list archive. There is a lot of good information
there, unfortunately it isn't so easy to find. 

> Maybe some of the standard modules could take
> advantage of this more (it would require some
> changes to their interfaces, I suppose).

Yes, the interfaces would have to change. I think it is better that the 
interfaces don't have type variables; really the most compelling (IMO of
course!) reason for making them polymorphic is to use the parameterization 
trick for recursive types, and I am hoping that a future OCaml (OCaml 4?) 
handles this nicely by stealing Moscow ML features or by adopting the
mixin modules described briefly here by Tom Hirschowitz a few months ago.

> The type signatures I get out of my module after
> converting it are a little odd looking:
> 
>     type 'a t = 'a
>     type 'a tree = Empty | Node of ...
>     val insert :
> 	('a t t t -> 'a t t -> bool) -> 
> 	'a t t t -> 'a t tree -> 'a tree
>     ...
> 
> Is there any useful information in the different
> number of t's?  They should all be equivalent, right?

Something looks wrong to me here. Could you post more of your code, or
provide a pointer to the original SML code? I don't see why you have a 
'a t t t. The OCaml code should look a lot like the SML code, and the
signatures should only differ a little.

> BTW, I opted for just passing the "lt" function
> as explicit arguments to all the functions in the
> module that need them. 

Why not just parameterize the module by the comparison function? 

> That seems like the most general approach, although it means some extra
> arguments and it doesn't guarantee consistency,
> as people might pass incompatible versions of "lt"
> to different calls;

Right, I think you should pull the comaprison out of the functions and 
parameterize the module for this reason. 

-- Brian


-------------------
To unsubscribe, mail caml-list-request@inria.fr.  Archives: http://caml.inria.fr