Re: porte des definitions des variables de classe

["Sylvain BOULM'E" <Sylvain.Boulme@lip6.fr>]

Bonjour,

> - elle est ambigue;
> Cela va a l'encontre du "sens commun". 

C'est vrai que ca peut sembler bizarre, mais je trouve 
cela assez coherent avec le reste de Ocaml.

Par exemple :

 let toto = let a=ref 0 in function () -> (a:=!a+1; !a)
 in (toto (); toto ());;

retourne 2

Alors que

 let tutu () = let a=ref 0 in function () -> (a:=!a+1; !a);;
 in (tutu () (); tutu () ());;

retourne 1

> D'ailleurs, il est confondant de voir que la déclaration suivante:
> class test3 > object
>     val mutable v = 5
>     method get = v
>     method set x = v<-x
> end;;

Il ne faut pas confondre variable mutable et reference. Une reference
est un "record" avec un champ mutable. 
  # ref 1;;
  - : int ref = {contents=1}
Donc si dans "let v=ref 1", v designe ce "record" et non pas le champ 
"mutable".

> Il suffit de supprimer ou d'ajouter un paramètre à une classe pour en changer
> complètement la sémantique.

C'est pareil pour "tutu" et "toto".

> - elle n'est pas consistante
> Rien ne me previent du changement de fonctionnalité dans ce cas particulier.
> Il suffit de supprimer ou d'ajouter un paramètre à une classe pour en changer
> complètement la sémantique.

> - elle n'est pas necessaire;
> Si on en a besoin, on peut simplement partager des variables "statiques"
> entre différentes instances de la meme classe.

> Enfin c'est mon avis d'utilisateur. Pour la petite histoire, il m'a fallu
> tout un weekend pour comprendre pourquoi mon code ne marchait plus sous
> OCaml-2.0, alors que la version 1.07 marche tres bien...

D'abord, sous Ocaml 1.07, on devait obligatoirement mettre un argument
a une classe : si on conserve cet argument, les classes Ocaml-2.0 se
comportent de la meme facon. Les classes de Ocaml-2.0 sont en fait plus
generales que celles de Ocam 1.07

En fait, pour eviter ces possibles confusions, je pense qu'on ne devrait
utiliser les variables d'instances "val" que vraiment quand elles sont des 
variables d'instances (ie quand elles sont destinees a evoluer, de facon
"imperative" ou "fonctionnelle", par copie d'objet). Sur mes exemples
precedents, on devrait ecrire test1 comme cela :
 
 class test1 = 
   let v=ref 5 in
    object
      method get= !v
      method set x= v:=x
    end;;


Par contre, il est vrai que je trouve surprenant que :

  class test2     let v=ref 5
    in fun () -> 
          object 
            method get = !v
            method set x = v:= x
         end;;

  let f=new test2 in 
    let a=f() and b=f() in (b#set 4; a#get);;

retourne 5

au lieu de retourner 4, comme on s'y attenderait....



Sylvain.