RE: hashtables for mutable records

["Coscoy, Yann" <yann.coscoy@icdc.caissedesdepots.fr>]

  Hello,

Pierre Weis wrote :

> You can use a unique integer field into your records 

  It is the solution I use. But, I dislike it because it makes necessary to
embed the record in some abstract type. (You must hide the constructor of
the recors to guaranty the uniqueness of the integer.)

> Of course you must use your own hashing function that just reads this
fixed integer field.

  I can do that, but it make impossible to use Hashtbl.Make because of the
poymorphism of the record. 

> As of polymorphism, if your problem is just to have keys or values
> belonging to a parameterized data type, you can directly use the
> creation and manipulation functions from the Hashtbl module
> (Hashtbl.create, Hashtbl.add, etc): they accept to manipulate
> polymorphic tables. Since usage of these functions with a user defined
> hash function is not available from the Hashtbl module, you should
> rewrite some parts of its code into your own hash table module.

I know I can solve my problem in this way. But I don't think that "cut,
paste, and patch the stdlib" is a good practice. So, I prefer to use the
integer itself as the key of hashtable and use the standard Hash module.

I partial solution would be to have another functor Make1 in module Hashtbl
with type 'a key. (It is just a partial solution, because it doesn't solve
the problem for type ('a, 'b) key and type ('a, 'b, 'c) key.)

 Yann coscoy

PS: the signature of this Make1 functor:

module type HashedType1 =
  sig
    type 'a t
    val equal: 'a t -> 'a t -> bool
    val hash: 'a t -> int
  end
  
module type S1 =
  sig
    type 'a key
    type ('a, 'b) t
    val create: int -> ('a, 'b) t
    val clear: ('a, 'b) t -> unit
    val add: ('a, 'b) t -> 'a key -> 'b -> unit
    val remove: ('a, 'b) t -> 'a key -> unit
  .....