Classe recursive et heritage

[Emmanuel Engel <Emmanuel.Engel@lri.fr>]

J'ai  une question  sur  les objets  et   l'heritage en O'caml.    Mon
probleme   est  relatif  aux  classes    recursives. Supposons que  je
definisse une classe ('a)tree de la facon suivante


class ('a)tree (g:('a)tree) (d:('a)tree)=
  val fg = g
  val fd = d
end;;


Supposons   maintenant que je souhaite deriver   cette  classe afin de
pouvoir rajouter  une attribut  aux  objets de cette  classe.  Quelque
chose qui serait equivalent a

class ('a)labelled_tree (g:('a)labelled_tree) (d:('a)labelled_tree)
(i:int)=
  val fg = g
  val fd = d
  val un_entier = i
end;;

Mon probleme  est  que   je  n'arrive  pas   a  deriver  cette  classe
directement, je  suis oblige de la definir  a la main, indepedament de
l'heritage et de compter sur le sous typage pour que la suite se passe
bien. Si je souhaite vraiement me servir  du sous typage, le mieux que
je puisse faire est

class ('a)labelled_tree (g:('a)labelled_tree) (d:('a)labelled_tree)
(i:int)=
  inherit ('a)tree g d
  val un_entier = i
end;;

Mais cela ne correspond  pas a mon  besoin puisque les fils gauches et
droit de cette nouvelle classe ne sont que des  arbres non decores. En
fait il  me semble que, ce  dont  j'ai besoin c'est,  dans la premiere
definition, d'une variable de type (type au sens typage) "self" qui me
permettrai alors de  dire que les fils  gauche  et droit sont  du meme
type  que  la classe (soit  le point  fixe de  cette definition). Cela
donnerai alors

class ('a) tree as 'self (g:'self) (d:'self) =
  val fg = g
  val fd = d
end;;

class ('a) labelled_tree g d (i:int) =
  inherit ('a)tree g d
  val un_entier = i
end;;

Dans ce  cadre la, le  inherit aurait pour   consequence de modifer le
point  fixe  de   la definition    pour  creer  la    nouvelle  classe
labelled_tree.  Mon probleme est que je n'ai  pas trouve comment faire
en  O'caml.  Est-ce possible? Si  non ou est  le probleme  ? Le typage
est-il casse par une telle  construction, est-ce indecidable ? Et dans
ce cas quelle est la difference entre  ce que ferai un telle solution,
integree au langage, et  la gestion a  la main  des points fixe  comme
semble le faire la solution suivante

class ('a,'b)node (g:'b) (d:'b)=
 val fg = g
 val fd = d
end;;

type ('a)my_tree = ('a,'t)node as 't;;

class  ('a,'b)labelled_node (g:'b) (d:'b) (i:int)=
 inherit ('a,'b)node g d
 val un_entier = i
end;;

type ('a)my_labelled_tree = ('a,'t)labelled_node as 't;;

Avec  ce codage,  il me  semble  que je  derive   une classe recursive
('a)my_tree pour  obtenir  la classe ('a)my_labelled_tree   mais c'est
plus fatigant a ecrire qu'une solution inscrite en dur dans le langage
et cela presente quelques  inconvenients, notamment lors de l'ecriture
de methodes recursives qui  vont m'obliger a  mettre une annotation de
type plus precise (height par exemple).

--

- Emmanuel Engel