Hello,

> Another solution is to turn "empty" into a function :
>    module type FOO1 = sig
>      type 'a foo
>      val empty : unit -> 'a foo
>    end;;
>    module Bar : FOO1 = struct
>      type 'a foo = 'a list Lazy.t
>      let empty () = lazy []
>    end;;

Would certainly also work. But I guess it is better to stay with the
functor - modules parameterized with a new value are not so common as
function invocations. Thus, I won't have to change this much code porting
Okasaki's sources.

> -----------------------------------------------------------

> Actually, it is still possible to make the coercion when the type of
> self only occur in covariant position (in particular, only on the
> right sides of arrows) :
>    class c = object (self)
>      method m = self
>    end;;
>    class d = object (self)
>      inherit c
>      method n = 1
>    end;;
>    let x = (new d :> c);;
> 
> There is a difficulty with "binary methods", where self type occurs in
> contravariant position :
>    class c = object (self : 'a)
>      method x = 1
>      method compare (o : 'a) = self#x = o#x
>    end;;
>    class d = object
>      inherit c
>      method y = 1
>    end;;
>    let x = (new d :> c);;     (* Fails *)

Unfortunately, it's the binary methods I need...

> However, you can coerce to a common supertype of c and d which has no
> method "compare" :
>    class type c' = object
>      method x : int
>    end;;
>    let l = [(new c :> c'); (new d :> c')];; (* Succeeds *)

That's the problem:
Actually the only method I would need is "compare" ;-)

Regards,
Markus

-- 
Markus Mottl, mottl@miss.wu-wien.ac.at, http://miss.wu-wien.ac.at/~mottl