Ocaml et les objets

Ocaml et les objets

[Vyskocil Vladimir]

Bonjour,

J'ai quelques questions sur la programmation objet avec objective caml
qui me pose probleme... Je commence a me rendre
compte qu'il faut oublier la vision C++ des objets car en caml les
notions d'heritage et de type ne sont pas tres lies mais justement ca
me pose des problemes. Par exemple si l'on veut creer une liste qui
contienne des objets derives d'un type parent il faut les "caster"
en ce type parent mais ensuite comment les recuperer en tant qu'objets
derives ? J'ai essaye le package Obj avec notamment la fonction
Obj.magic mais ca me parait un peu risque et je n'arrive pas a faire une
fonction qui puisse renvoyer un objet derive quelconque car justement il
n'ont pas des types compatibles, quand est t'il du type #class_parent
qui est sense etre compatible avec tout les objets descendants de la
classe class_parent ? En fait ce qui me perturbe le plus c'est a quoi
sert l'heritage si les objets derives ne sont pas compatible entre eux ?

Voici un exemple :

class object (class_name : string) =
  val name = class_name

  method get_name = name

and o_int (new_i : int) =
  inherit object "o_int"
  
  val i = new_i 
 
  method get_value = i

and o_float (new_f : float) =
  inherit object "o_float"
  
  val f = new_f 

  method get_value = f
end

let o1=new o_int 1;;
let o2=new o_float 2.5;;
let l = [(o1 :> object); (o2 :> object)];;

(* ces fonctions permettent de convertir un objet generique *)
(* en objet derive                                          *)
let o_int o = (Obj.magic o : o_int);;
let o_float o = (Obj.magic o : o_float);;

(* mais comment ecrire une fonction qui a partir du nom de  *)
(* de l'objet (methode get_name) renvoie soit un o_int soit *)
(* soit un o_float ?                                        *)


Merci d'avance si vous pouvez m'eclaircir les idees a ce sujet...

-- 
Vyskocil Vladimir
vyskocil@math.unice.fr
http://www.inria.fr/safir/WHOSWHO/Vladimir.html

Re: Ocaml et les objets

[Francois Rouaix]

> Par exemple si l'on veut creer une liste qui
> contienne des objets derives d'un type parent il faut les "caster"
> en ce type parent mais ensuite comment les recuperer en tant qu'objets
> derives ?
Une fois qu'on a "oublié" le vrai type d'un objet, on ne peut plus y
revenir, parce que le typage est statique. Redescendre dans la hiérarchie
des types imposerait une vérification de type à run-time.
Par contre, l'objet lui-même garde son type, et si cet objet a été lié
avec son vrai type dans l'environnement, on y a toujours accès.
De plus, il ne faut pas oublier que le polymorphisme s'applique aussi
aux interfaces.

> J'ai essaye le package Obj avec notamment la fonction
> Obj.magic mais ca me parait un peu risque
En effet. Le système de types est là pour garantir que le programmeur
fait les choses proprement. Utiliser Obj.magic est une mauvaise idée.

> et je n'arrive pas a faire une
> fonction qui puisse renvoyer un objet derive quelconque car justement il
> n'ont pas des types compatibles,
Une fonction ne peut pas renvoyer des valeurs de type "variable", sauf
lorsqu'elle est polymorphe et qu'elle connait le vrai type en entree.

A mon avis, si on doit avec plusieurs objets de types differents (A, B, C)
mais dont l'interface a un sous-ensemble commun I, on peut tres bien les
mettre dans une liste et ensuite faire des traitements ou transformations
sur cette liste pourvu que ces traitements soient en realite dans des
methodes des classes A, B et C. On peut meme avoir des methodes qui
"copient" des objets, comme dans l'exemple (incomplet) suivant:

let o1 = new A
and o2 = new B
and o3 = new C
let l = [(o1 :> I); (o2 :> I); (o3 :> I)]
let f l = List.map (fun o -> o#m)) l
let l' = f l


Ci-joint une version de ton exemple:

class virtual object (class_name : string) : 'a   val name = class_name

  method get_name = name
  virtual m : 'a

and closed o_int (new_i : int)   inherit object "o_int"
  
  val i = new_i 
  method get_value = i

  method m = new o_int (i+1)

and closed o_float (new_f : float)   inherit object "o_float"

  val f = new_f 
  method get_value = f

  method m = new o_float (f+.1.0)

end

let o1=new o_int 1;;
let o2=new o_float 2.5;;
let l = [(o1 :> object); (o2 :> object)];;
 (* val l : object list *)

let incremente l = List.map (fun o -> o#m) l;;
 (* val incremente : < m : 'a; .. > list -> 'a list *)

let l' = incremente l;;
 (* val l' : object list *)


--f