Version française
Home     About     Download     Resources     Contact us    
Browse thread
[Caml-list] subtyping, polymorphism, higher order types.....
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Jacques Garrigue <garrigue@k...>
Subject: Re: [Caml-list] subtyping, polymorphism, higher order types.....
From: Vasile Rotaru <vrotaru@seznam.cz>
> On Thu, 03 Jul 2003 10:33:15 -0400
> Shaddin Doghmi <shaddin@mitre.org> wrote:
> 
> > In my experiences with ocaml, one of the major frustrations i
> > constantly run into is the lack of subtyping. [..]

You should be a bit more precise: ocaml has both explicit subtyping
(for objects), and parametric polymorphism (which is also a form of
implicit subsumption). So what it does not have is only the form of
implicit subtyping you are used to, and which is incompatible with
most forms of type inference.

>   The Shaddin message (and other influences -- the most notable being
> the Oberon language) had induced me to an idea which I offer here for
> discussion. Open (or extensible) product types. Something like this
> 
>     type point = int * int * _ ;;
> 
> where the underscore stands for any sequences of types. Colour, taste,
> strangeness, etc.
> 
>   Now a function designed to work with with "point" will work with any
> type which is a "point" extension. Just now I cannot think of a good
> "ocamlish" syntax for extending types. Maybe?
> 
>     type color_point = <point> * int * _
> 
>   The big question is what this will do with the type system of Ocaml
> and whether it worth the pain..

This looks very much like an ocaml object type to me...
Is the absence of labels for fields important?

Note that you can also encode the above with polymorphism:

  type 'a point = int * int * 'a
  type 'a color_point = (int * 'a) point

The only trouble here is that there is no way to create heterogeneous
collections, since you cannot coerce a [unit color_point] to a [unit
point]. Actually, this just comes from a missing relation in the ocaml
type algebra: the type Obj.t is not recognized as a supertype for all
types. If this were the case then you would be able to write:
  let l = [ (p :> Obj.t point); (cp :> Obj.t point) ]

That would be easy enough to add, but is it that useful?

     Jacques Garrigue

-------------------
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