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
[Caml-list] sum types with objects
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: 2003-11-26 (13:32)
From: Didier Remy <remy@m...>
Subject: Re: [Caml-list] sum types with objects
Tom Hirschowitz <Tom.Hirschowitz@ens-lyon.fr> writes:

> when trying to implement lists with objects and classes, I run into
> the following issue.
> The idea is to define a class type list, parameterized over the type
> 'a of elements, and containing the methods is_nil, hd, tl, map. Then,
> I planned to define two classes nil and cons for building objects of
> type list.

See polymorphic methods in the manual. 

Still, you should use fold and not map:

    class type ['a] list = object
      method is_nil : bool
      method hd : 'a
      method tl : 'a list
      method fold  : 'b. ('a -> 'b -> 'b) -> 'b -> 'b

    exception Nil;;
    class ['a] nil = object (self : 'a #list)
      method is_nil = true
      method hd = raise Nil
      method tl = raise Nil
      method fold f x = x

    class ['a] cons h t = object (self : 'a #list)
      method is_nil = false
      method hd = h
      method tl : 'a list = t
      method fold f x = f self#hd (self#tl#fold f x)

Otherwise, your are trying to define a type abbreviation 

    type ('a, ...) #list = 
         < hd : 'a
           tl : 'a list
           map : 'b. ('a -> 'b) -> ('b) list; ... >

    and 'b list = ('b, <>) list

which is not allowed because the parameter of list in the body is not the
same as the one in the declaration. Type inference will enforce 'b = 'a, 
which is not what you want.

This is not just a matter of typechecking, though.  In particular, 
if you had in mind an implementation of class cons of the form 

     class cons h t = 
       method map f = new cons (f self#hd) (self#tl#map f)

you would then have problems inheriting, since the constructor "new cons" is
here the one of the class "cons" beeing defined and not the one of a
subclass. Hence, you would also need to abstract cons over the constructor
function of the subclass of cons beeing considered, which becomes closer to
(but still less general than) what fold actually does.


To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners