Re: [Caml-list] Re: module typing issue

[Guillaume Yziquel <guillaume.yziquel@citycable.ch>]

Le Monday 28 Mar 2011 à 14:23:50 (+0200), Alain Frisch a écrit :
> On 03/28/2011 01:58 PM, Guillaume Yziquel wrote:
> >Yes an no. From a type inference perspective, that's right. However, you
> >can already do such pattern matching on private row types for variant
> >types.
> >
> >module X : sig
> >	type t = private [<  `A ]
> >	val x : t
> >end = struct
> >	type t = [ `A ]
> >	let x = `A
> >end
> >
> >match X.x with `A ->  ()
> >
> >and the X.x is correctly unified with `A. So the type inference issue is
> >solved in this case.
> 
> Private row types are not the same as private type abbreviations.
> The syntax might be a source of confusion here, but the keyword
> "private" really means three different things:

Yes. I just find it too bad that the distinction between these three
different 'private' types is so neat.

> - Private type declarations: constructors/labels are available for
> deconstructing values (pattern matching, dot notation), not for
> building values.

That's where I'd like type t = private int to stand at times. Having it
as a private type abbreviation is sometimes too strong.

> - Private type abbreviations (where the abbreviated type is not an
> object type or a polymorphic variant type): the behavior is very
> much the same as an abstract type, except that the abbreviation is a
> subtype of the abbreviated type (and the compiler can use the
> concrete type to choose a runtime representation of -- e.g. for
> records of floats -- and to trigger optimizations).

Yes. I'm just sad that when you have predefined pattern-matching way to
deal with a type (such as strings or ints), these private type
abbreviations drop the deconstructing features of private type
declarations.

> - Private row types: you can think of the 'private' annotation as a
> way to name (as an abstract type) the implicit row type variable of
> the abbreviated type. There is no hiding as for type abbreviation
> and no access control as for private type declarations.

Yes. And in a signature, you can replace them with the 'with type :='
construct. This is again different, and also handy.

> The syntax for private type abbreviation and private row types is
> the same; they are distinguished only in the type-checker. As far as
> I know, there is no way to create a private type abbreviation on a
> object or variant type.

Except than aliasing the object or variant type to another type and
doing a private type abbreviation on the alias.

> Alain

-- 
     Guillaume Yziquel