Version française
Home     About     Download     Resources     Contact us    
Browse thread
[Caml-list] record labels of record scope using camlp4
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Didier Remy <Didier.Remy@i...>
Subject: Re: [Caml-list] record labels of record scope using camlp4
> Another way would be to use type information provided by the type-checker.
> For accessing field, here is a description of a simple patch to the
> type-checker that could be handy; the idea is that, when the expression e
> is known to be a record of a given type, one can use a "record scope" rule
> for label. 

Isn't this just a form of static and local resolution of overloading?
However, local resolution does not commute with unification...
Hence, the specification of well-typed programs should then strongly
depend on the order in which unifications (i.e. type inference) are 
performed. Do you have a specification of well-typed programs but
the type-inference algorithm itself? 

> A ten-minutes hack leads me to:

[...]

> This patch allows to write things like:
> 
> type t = { x : int; y : int };;
> type s = { x : string };;
> let f (t : t) : int = t.x;;
> 
> The same could be done for record expression (in function type_expect):
> 
> let r : t = { x = 2; y = 3 } in
> ...

> On the one hand, this kind of interaction with the type-checker is quite
> dangerous as it breaks complete type inference, but in OCaml, there are
> already some cases where type annotations are mandatory; on the other
> hand, it leads to a lightweight syntax and is probably what programmers
> expect.

It is true that Ocaml differs from the nice theory of core ML in a few
places.  However, we have tried to keep those differences as unsignificant
as possible, and as few as possible.

For example, a module with a weak type variable in its principal signature
is rejected, while any ground instantiation of this weak type variable would
be accepted, so, yes: ``Ocaml does not have principal types''. However, type
inference is still easy to specify, and in particular does not rely in which
operations are performed.

        Didier
-------------------
Bug reports: http://caml.inria.fr/bin/caml-bugs  FAQ: http://caml.inria.fr/FAQ/
To unsubscribe, mail caml-list-request@inria.fr  Archives: http://caml.inria.fr