Dear Rémy,

The trouble here is that Hashtbl.S defines an abstract type for hash
tables, and that each time you open this module, using the (module H :
Hashtbl.S) pattern, your are talking about a fresh abstract type,
incompatible with anything from the outside world. In particular, there is
no way the parameter ht could have this type, and this causes an error.

Contrary to real functors, first-class modules do not let you connect
abstract parameterized types with the outside world. So in this case, the
only solution I see would be to pack your hash table inside the module
itself, like for an object, so that you don't need to receive ht as a
separate argument.

Jacques Garrigue
2015/06/16 21:16 "Rémy El Sibaïe Besognet" <remy.el-sibaie@lip6.fr>:

> Hi all,
>
> Considering this function
>
> let find ht x =
>   Hashtbl.find ht x
>
>
> I would like to write a more general `find` function which takes the
> module
> as first class module in parameter with the possibility to use it on
> different implentations of Hashtbl.S.
>
> let find (module H : Hashtbl.S) ht x =
>   H.find *ht* x
>
>
> but it failed with this error (on the underlined identifier) :
>
> *Error: This expression has type 'a H.t but an expression was expected of
> type         'a H.t       The type constructor H.t would escape its scope*
>
>
>
> I also tried by specifying the implementation but had the same problem:
>
> let find (type a) (module H : Hashtbl.S with type key = a) (ht : 'a Ht.t) (x : a) =
>
> H.find ht x
>
> Anyone has an idea how to achieve this thing ?
>
> Thanks,
> - Rémy El Sibaïe, LIP6
>
>
>
> PS: at the begining, I was trying on a memoization function which has more
> interest than the previous function :
>
> let memo_rec (module H : Hashtbl.S) h f =
>   let rec g x =
>     try H.find h x with
>     | Not_found ->
>       let y = f g x in
>       H.add h x y; y
>   in g
>
>