Re: [Caml-list] writing a not too simple parametrized class interface

[Jacques Garrigue <garrigue@math.nagoya-u.ac.jp>]

On 2011/01/15, at 2:46, Philippe Strauss wrote:

> Hello ocaml users,
> 
> I'm in a fight with hindley-milner when writing a .mli for a set of classes which implement a pipeline pattern, for processing either float array or Complex.t array, caching the result in each pipeline element.
> 
> each element type (class) inherit from node_virt_t, which use parametrized type for circumventing around the lack of "c++" like method overloading, for having the ability to use either float array or Complex.t array as input/output data type.
> 
> the whole things works perfectly, but the .mli seems not easy to write.
> uncomment class node_spectrum_t or class node_mag_t and you'll get:
> 
> File "nodes.mli", line 68, characters 30-45:
> Error: The type parameter Complex.t array
>       does not meet its constraint: it should be float array
> 
> which I don't understand.

[...]
The problem can be tracked down to this single line:

> class virtual ['b, 'c] node_virt_t : ('a, 'b) node_virt_t -> parameters_t -> int -> int -> [...]

Object types are allowed to be recursive, but they are restricted to _regular_ types,
where recursive occurences have identical type parameters.
In particular, this means that in the above line, ('a,'b) node_virt_t and ('b,'c) node_virt_t
must have the same parameters, i.e. that 'a = 'b and 'b = 'c, i.e. all your types
end up being identical.

But in your particular case, the recursion seems unnecessary.
You could write:

class type ['b, 'c] node_t :
   object
       method get_id : int -> int
       method private inc_id : int -> unit
       method virtual ptyp : unit -> node_parameters_t
       method virtual process : 'b -> 'c
       method private pstore : int -> int * int * 'c
       method get : int -> int * int * 'c
end

class virtual ['b, 'c] node_virt_t : ('a, 'b) node_t -> parameters_t -> int -> int ->
   object
       val previous : ('a, 'b) node_t
       val parms : parameters_t
       val hres : (int * int * string, 'c) Hashtbl.t
       val mutable id : int array
       inherit ['b,'c] node_t
end

Hopefully, this should solve your typing problem.

Of course, you might also consider whether you really need to use objects for that.
Closures are usually enough for cacheing, and they do not involve the advanced
aspects of the type system.

Jacques Garrigue