Hi,

I was reading the ocaml manual section 1.5 where an explicit polymorphic type can be declared.  I wanted to know if the trailing dot '.' is a special case "marker" only and does not have anything to do with how we distinguish floating point multiplication, division, subtraction, and addition, and nothing to do with accessing the elements of an array. Without the trailing dot we cannot declare any such polymorphic fields no how, no way. I was also surprised to find this was possible.

[The manual says] In some special cases, you may need to store a polymorphic function in a data structure, keeping its polymorphism. Without user-provided type annotations, this is not allowed, as polymorphism is only introduced on a global level. However, you can give explicitly polymorphic types to record fields.

# type idref = { mutable id: 'a. 'a -> 'a };;
type idref = { mutable id : 'a. 'a -> 'a; }

# let r = {id = fun x -> x};;
val r : idref = {id = <fun>}

# let g s = (s.id 1, s.id true);;
val g : idref -> int * bool = <fun>

# r.id <- (fun x -> print_string "called id\n"; x);;
- : unit = ()

# g r;;
called id
called id
- : int * bool = (1, true)

I am having difficulty reading the first line, the type declaration "type idref = { mutable id : 'a. 'a -> 'a } ;;"  When I look at the way we are accessing the field values on line 3, it does look like accessing member fields in other languages and it does superficially resemble array indexing as in "let str = "abcdef" ;; str.[1] ;; -: char = 'b'".  The two ways we are using the dot '.' are very distinct. Is that correct? The second is the common place indexing, whereas the first is just a "marker".  I could not declare the fields for example as a polymorphic tuple for instance: "type idref = { mutable 'a * 'b -> 'a }" nor "type idref = { mutable 'a. 'b -> 'a }". The latter is just nonsense, the 'b is undefined. But we could have a two field record by just repeating the type definitions. "let idref = { mutable 'a. 'a -> 'a; mutable 'b. 'b -> 'b }". The polymorphic type does not have any restriction, it appears we could have any fundamental type we wanted. The type 'a variable must be repeated, it is not enough to say "type idref = { mutable 'a. -> 'a };;" Is it correct then to read the declaration in this way: the type 'a polymorphic type as a polymorphic variable of type 'a. I know it sounds redundant, but that is how I am reading the syntax.

Thank you for clarifying this for me.

jean