From: Damien <Damien.Pous@ens-lyon.fr>
> > > Does someone know why the following class type
> > > is not accepted ?
> > > 
> > > # class type a = object method m: 'a. (#a as 'a) -> unit end;;
> > > The abbreviation #a expands to type #a but is used with type < .. >
> > [...]
> > Now, the serious part: can such a type be defined?
> > After working a bit on this riddle, I'm afraid the answer is no.
> > The reason is that there is no way to recurse on a quantified
> > polymorphic method rather than on the whole object.
> > The closest I found is:
> >   class type a =
> >     object method m : < d : 'b. (< m : 'a; .. > as 'b) -> unit > as 'a
> >     end
> > The dummy wrapper <d : 'b. ... > is just there to allow one to recurse
> > on the polymoprhic method itself. You can call the method m by doing
> > [a#m#d a'] in place of [a#m a'].
> I worked with this class type, but it is a bit tedious :-(
> 
> My goal is to define a tree, whose node's type is a class
> type a_t, containing a method for adding children.
> but the child type can be any subtype of a_t
> 
> * this method can safely be typed [a_t->unit], but this will require a
> lot of coercions in the rest of the code...
> 
> * that's why I wanted to type it ['a. (#a_t as 'a)->unit] (i.e. the
> coercion is written only once, in the method)
> 
>  using your trick, I obtained the attached code. It works fine,
> but that's not really a beautiful piece of code !

And I would not have expected it to be!
This was just a theoretical answer.

If you are bothered by coercions, you may have a look at the trick in
lablgtk, which avoids polymorphic methods: give the parent as
argument.
let new_node ?parent () =
  let n = new node in
  begin match parent with None -> ()
  | Some (p : #a_t) -> p#add (n :> a_t)
  end;
  n
You can also do the trick in an initializer.

Alternatively, you might just have an interface of a_t without
the method m. This way you have no problem with recursion:

class type a0_t = object
  ... everything but add ...
end
class type a_t = object
  inherit a0_t
  method add : #a0_t -> unit
end

> I don't know what do you mean when saying 
> "such a type cannot be defined", in fact, I could define this 
> equivalent (I think it is...) :
> 
> >#class type a_t = object 
> >   method m: 'a.(<m: 'a -> unit; ..> as 'a) -> unit 
> >end 

This is not equivalent: the m in a_t is a polymorphic method, but not
the one in the recursion. Polymorphic and monomorphic methods are
incompatible, so you cannot pass an a_t to m.

Jacques Garrigue

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners