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

[Alain Frisch <alain@frisch.fr>]

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:

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

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

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


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.



Alain