English version
Accueil     À propos     Téléchargement     Ressources     Contactez-nous    

Ce site est rarement mis à jour. Pour les informations les plus récentes, rendez-vous sur le nouveau site OCaml à l'adresse ocaml.org.

Browse thread
polymorphic method.
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: 2009-09-10 (13:09)
From: Guillaume Yziquel <guillaume.yziquel@c...>
Subject: Re: [Caml-list] polymorphic method.
Jacques Garrigue a écrit :
> There are already polymorphic methods in ocaml.
> The syntax for your example would be:
> class myobject = object
>   method id : 'a. 'a -> 'a = fun x -> x
> end

Yes, I know that there are already polymorphic methods in ocaml.

> A "polymorphic" keyword might seem simpler, but it would be complex to
> handle the case where a polymorphic method type contains also class
> parameters:
> class ['a] cell (x : 'a) = object
>   method pair : 'b. 'b -> 'a * 'b = fun y -> (x,y)
> end

Indeed. But you could also write:

class ['a] cell (x: 'a) = object
   polymorphic method pair y = (x, y)

The polymorphic keyword would only bind what can be bind. Since x is 
already of type 'a, it would escape the scope of the 'polymorphic' 
keyword. But y would not escape the scope of the polymorphic keyword.

> More generally, you might end up with types more polymorphic than you
> expected, and since differently instantiated polymorphic method types
> are incompatible, this would be a problem.

Well, for now, when I write methods, my methods tend to be not 
polymorphic enough. One could keep the default behaviour without the 
keyword, and also use the keyword polymorphic to bind only what can be 
bound (i.e. not 'x' in your example).

The problem I am facing now is cumbersome: writing types for methods 
arguments everywhere... That's not what people would expect for type 
inference, unfortunately. The 'polymorphic' keyword would only be a hint 
as to how type inference would be done. This way I wouldn't have to keep 
the typing of the method arguments in sync with the code of the method 
(or at least, much less).

By the way, I do not exactly understand the "you might end up with types 
more polymorphic than you expected" part.

> Jacques Garrigue

      Guillaume Yziquel