Constante NIL

Constante NIL

[Vyskocil Vladimir]

Bonjour,

N'est t'il pas concevable de rajouter a Objectif Caml une constante
NIL, UNDEF ou je sais pas trop comment la nommer dont la valeur serait
'_a. Ceci permettrait d'initialiser "par defaut", par exemples, 
les variables d'instances d'une classe lorsque l'on ne possede aucune
valeur par defaut du bon type. Je sais qu'il y'a toujours la possibilite
d'utiliser le type 'a option mais ca devient lourd a gerer...
Comme pour le type "special" '_a, la variable d'instance prendrait le
bon type des qu'il est connu.

J'utilise actuellement CamlTk encapsulé par des classes et cette
situation
se presente frequement, par exemple (en simpifié) :

class toplevel parent =
  object
  end
;;

class bouton parent =
  object
  end
;;

class boite parent =
  let win = new toplevel parent in
  object (self)
   inherit toplevel parent
   method get_win = win
end
;;

class ma_boite parent =
  object (self)
  inherit boite parent as super
  val mutable bt = ???           (* <- que mettre ici ? *)   
 
  initializer 
    (* ici l'objet est initialise donc on peut recuperer le parent *) 
    bt = new bouton super#get_win  
end
;; 

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

Re: Constante NIL

[Francois Rouaix]

> N'est t'il pas concevable de rajouter a Objectif Caml une constante
> NIL, UNDEF ou je sais pas trop comment la nommer dont la valeur serait
> '_a. Ceci permettrait d'initialiser "par defaut", par exemples,  les
> variables d'instances d'une classe lorsque l'on ne possede aucune
> valeur par defaut du bon type.


In this particular case (dummy initialization value for a CamlTk 
widget), you could use Widget.default_toplevel, or Widget.dummy.
It's inelegant and a bit dangerous, but neither as bad as using
a Widget.widget option type, or as drastic as adding null pointers
in the language.

--f

Re: Constante NIL

[Jean-Francois Monin]

> N'est t'il pas concevable de rajouter a Objectif Caml une constante
> NIL, UNDEF ou je sais pas trop comment la nommer dont la valeur serait
> '_a. Ceci permettrait d'initialiser "par defaut", par exemples, 

Ca m'est arrive d'utiliser Obj.magic, par exemple :

type ('a, 'b) cell = 
	{mutable lft : 'b; c : key; mutable v : 'a; mutable rgt : 'b}
let any_c : unit -> key = Obj.magic
let any_v : unit -> 'a = Obj.magic
let env_init () = {lft=Empty; c=any_c (); v=any_v (); rgt=Empty}

-- 
Jean-Francois Monin, CNET DTL/MSV,          Tel +33 2 96 05 26 79
2 av. Pierre Marzin, 22307 Lannion, France  Fax +33 2 96 05 39 45
SANS TRAIT D'UNION :     JeanFrancois.Monin@cnet.francetelecom.fr

Re: Constante NIL

[Xavier Leroy]

> N'est t'il pas concevable de rajouter a Objectif Caml une constante
> NIL, UNDEF ou je sais pas trop comment la nommer dont la valeur serait
> '_a. Ceci permettrait d'initialiser "par defaut", par exemples, 
> les variables d'instances d'une classe lorsque l'on ne possede aucune
> valeur par defaut du bon type. Je sais qu'il y'a toujours la possibilite
> d'utiliser le type 'a option mais ca devient lourd a gerer...

Le problème de la constante "nil" est d'assurer qu'elle n'est pas
utilisée comme une valeur "normale" du type en question.  Cela
signifierait générer des tests à "nil" avant chaque accès dans une
structure de données (de la même manière que les compilateurs Java
doivent tester si les objets ne sont pas "null").  C'est coûteux en
taille de code et en temps d'exécution, et diminue la robustesse des
programmes.

L'utilisation du type 'a option est certes lourde mais a le mérite de
rendre ces tests explicites et optimisables par le programmeur.

Quant à utiliser Obj.magic, je le déconseille car le programme peut
alors très bien planter s'il utilise par erreur la valeur "nil" comme
une valeur normale.  (Oui, j'ai essayé; et oui, mon code a fini par
planter à cause de cela.)

- Xavier Leroy

Re: Constante NIL

[Pierre Weis]

> > N'est t'il pas concevable de rajouter a Objectif Caml une constante
> > NIL, UNDEF ou je sais pas trop comment la nommer dont la valeur serait
> > '_a. Ceci permettrait d'initialiser "par defaut", par exemples, 
> > les variables d'instances d'une classe lorsque l'on ne possede aucune
> > valeur par defaut du bon type. Je sais qu'il y'a toujours la possibilite
> > d'utiliser le type 'a option mais ca devient lourd a gerer...

As Xavier pointed out a nil constant is fairly difficult and runtime
consuming to implement in Caml. On the type level, you cannot assign
it the ``for all 'a. 'a'' type scheme, since otherwise you would get
as many ``bus errors'' as you want (nil can be considered a function
with such a type scheme). Uses of Obj.magic has also to be prohibited
for the same reasons (fairly too difficult to avoid bus error).

> Le problème de la constante "nil" est d'assurer qu'elle n'est pas
> utilisée comme une valeur "normale" du type en question.

Right. So why not considering a nil construct that IS always a value
of the corresponding type ?

You may consider to add a special construct ``any'' to the language,
known by the typechecker and the compiler. The typechecker would
ensure that ``any'' is never used in a (fully) polymorphic way, and
the compiler may generate the code to build a value of the type
assigned to ``any'' by the typechecker. This way, you would get for
instance:

#(any : int);;
0 : int

#(any : string);;
"" : string

#(any : 'a list);;
[] : 'a list

But still, any is not a ``nil'' polymorphic value:

#any;;

Compilation Failed: cannot create a value of type 'a

And this could work just fine for more complicated (and polymorphic)
data structures:

#type 'a dlist = {mutable hd : 'a dlist; mutable tl : 'a dlist};;
Type dlist is defined

#let l = (any : 'a dlist);;  
Value l is dlist0
      where dlist0 = {hd=dlist0; tl=dlist0} : '_a dlist

Hope this helps,

Pierre Weis

INRIA, Projet Cristal, Pierre.Weis@inria.fr, http://cristal.inria.fr/~weis/