"Luca de Alfaro" <luca@dealfaro.org> writes:
> class p (x: int) = object
>   method plus1 : int = x + 1
> end
>
> class p2 (x: int) = object
>   inherit p x
>   method plus2 : int = x + 2
> end
>
> class r = object (self)
>   val mutable l = []
>   method make_el x = new p x
>   method add (x: int) : unit = l <- (self#make_el x) :: l
>   method length : int = List.length l
>   method total : int = List.fold_left (fun t el -> t + el#plus1) 0 l 
> end
>
> class r2 = object
>   inherit r
>   method make_el x = new p2 x
>   method total2 : int = List.fold_left (fun t el -> t + el#plus2) 0 l 
> end

I tried it in another way, maybe not the way you expect, but just for your
reference.

<code>
class virtual r = object
  val mutable l = []
  val virtual make_el: int -> #p
  method add x = l <- make_el x ::l
  method length = List.length l
  method total = List.fold_left (fun t el -> t + el#plus1) 0 l
end
class r1 = object inherit r val make_el = new p end
class r2 = object inherit r 
  val make_el = new p2 
  method total2 = List.fold_left (fun t el -> t + el#plus2) 0 l
end
</code>

Note that before you finally provide the virtual classes with a concrete
make_el, you're free to inherit and extend them *arbitrarily*. E.g.

<code>
class virtual r3 = object inherit r
  method total3 = List.fold_left (fun t el -> t + el#plus3) 0 l
end
class virtual r4 = object inherit r3 (* r3 is extensible *)
  method total4 = List.fold_left (fun t el -> t + el#plus4) 0 l
end
</code>

HTH.
-- 
Zheng Li
http://www.pps.jussieu.fr/~li