Hello,

Thomas Gazagnaire wrote:
> or if you really want to define your own equality, you can use recursive 
> modules:
> 
> module rec H : Hashtbl.HashedType =
> struct
>     type node =
>         | Node of node J.t
>         | Leaf of int
> 
>     type t = node
>     let equal (e1:node) (e2:node) = (==) e1 e2
>     let hash (e:node) = Hashtbl.hash e
> end
> 
> and J : Hashtbl.S = Hashtbl.Make( H )


Just to inform you, in case you are interested, that the definition
above does not quite solve my problem. A small test shows that I still
have the same issue I originally had with the hash-table keys:

# open H ;;

# let no_jumps = J.create 13 ;;
val no_jumps : '_a J.t = <abstr>

# let empty = Node(no_jumps) ;;
val empty : H.node = Node <abstr>

# let _ = J.add no_jumps empty empty ;;
This expression has type H.node but is here used with type J.key

To solve this we need to explicitly declare that
Hashtbl.S.key = H.node. So I use:

module rec H :
   sig
       type node =
           | Node of node J.t
           | Leaf of int

      type t = node
      val equal : t -> t -> bool
     val hash : t -> int
   end =
   struct
        type node =
           | Node of node J.t
           | Leaf of int

       type t = node
       let equal (e1:node) (e2:node) = (==) e1 e2
       let hash (e:node) = Hashtbl.hash e
   end

and J : Hashtbl.S with type key = H.node = Hashtbl.Make( H )
;;

(Note: I made the type "t" of H visible to facilitate coding)
And it now works as expected:

# open H ;;
# let no_jumps = J.create 13 ;;
val no_jumps : '_a J.t = <abstr>

# let empty = Node(no_jumps) ;;
val empty : H.node = Node <abstr>

# let _ = J.add no_jumps empty empty ;;
- : unit = ()

# let x = J.find no_jumps empty ;;
val x : H.node = Node <abstr>

# let r = x == empty ;;
val r : bool = true

Once again,
Thank you,

Hugo F.



> 
> 2009/1/19 Jacques Carette <carette@mcmaster.ca <mailto:carette@mcmaster.ca>>
> 
>     Hugo Ferreira wrote:
> 
>         I am attempting to define a type so:
> 
>         type node =
>          | Node of links
>          | Leaf of int
> 
>         And I want to implement links as a
>         hashtable whose keys and values are
>         also of type node.
> 
> 
>     type node =
>      | Node of links
>      | Leaf of int
>     and links = (node, node) Hashtbl.t
> 
>     should do it.
> 
>     Jacques
> 
> 
>     _______________________________________________
>     Caml-list mailing list. Subscription management:
>     http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
>     Archives: http://caml.inria.fr
>     Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
>     Bug reports: http://caml.inria.fr/bin/caml-bugs
> 
> 
> 
> ------------------------------------------------------------------------
> 
> _______________________________________________
> Caml-list mailing list. Subscription management:
> http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
> Archives: http://caml.inria.fr
> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> Bug reports: http://caml.inria.fr/bin/caml-bugs