Hi all,

how can I pass a generic class type inside a signature without
actually specifying the class itself ?

this is a broken example :

module type S = sig type t end
module Make ( T:S ) = struct
  let init = new T.t
  let add s e = s#add e
end

this is the best I figured out :

module type S =
sig
   type c = < add : int -> 'c > as 'c
   val make : unit -> c
end

module Make ( T:S ) = struct

  (* let init = new T.c *)
  let init = T.make ()
  let add e = init#add e

end
      
but it isn't satisfactory as I've to pass a 'make' function and
if I try to instantiate the module with a super class of c, it gives 
me a signature error. For example:

class test : c =
    object
        val data = []
        method add (e :int) = {< data = e::data >}
        method other = 1
    end

module A = Make (struct class c = test let make () = new test end)

doesn't work because

Signature mismatch:
Modules do not match:
  sig class c : test val make : unit -> test end
is not included in
  S
Type declarations do not match:
  type c = < add : int -> c; other : int >
is not included in
  type c = < add : int -> 'a > as 'a

the class c in the signature should be a class that has 'at least' a
method add with respect to the signature, but it can actually be any
arbitrary class...

how can I achieve this ?

Basically I'd like to say: 
type c = < add : int -> 'a; .. > as 'a

but this doesn't work...

:)
p

-- 
++ Blog: http://blog.rsise.anu.edu.au/?q=pietro
++ 
++ "All great truths begin as blasphemies." -George Bernard Shaw
++ Please avoid sending me Word or PowerPoint attachments.
   See http://www.fsf.org/philosophy/no-word-attachments.html