Accueil     À propos     Téléchargement     Ressources     Contactez-nous

Ce site est rarement mis à jour. Pour les informations les plus récentes, rendez-vous sur le nouveau site OCaml à l'adresse ocaml.org.

Defining type that requires hashtables with recursive definition
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
 Date: 2009-01-20 (10:09) From: Hugo Ferreira Subject: Re: [Caml-list] Defining type that requires hashtables with recursive definition
```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 =
>          | Leaf of int
>
>         And I want to implement links as a
>         hashtable whose keys and values are
>         also of type node.
>
>
>     type node =
>      | 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

```