Tuple projections

[johnyob]

Rendered version

TL;DR: Adds labeled and (0-indexed) unlabeled tuple projections:

# let x = (~tuple:42, ~proj:1337, "is", 'c', 00, 1);;
val x : (tuple: int * proj:int * string * char * int * int) = 
  (~tuple:42, ~proj:1337, "is", 'c', 0, 1)
# x.tuple;; 
- : int = 42
# x.3;;
- : char = 'c'

[samsa1]

Did you mean discombulating_record instead of foo ?

[johnyob]

Fixed in latest version

[samsa1]

Here we might want to have the same semantic as with

let get_y t =
  let ~y, .. = t in
  y

which is rejected if I remember correctly.

We would also need to check that the back-end supports such polymorphism (I remember talking about a usefull feature similar to this one for modules with @lthls)

[johnyob]

Yes, this is rejected currently since the expected type of the pattern (i.e. the type of t) is not known

[samsa1]

What happens in the case :

let x = ~a:1, ~b:2 in x.1

Is the example rejected because only x.a and x.b are accepted and not x.0/x.1 ?

[johnyob]

This would be rejected, as you correctly surmise, the only well-typed projections for x would be x.a, x.b.

This is consistent with the current pattern matching semantics i.e. the following is ill-typed:

# let x = ~a:1, ~b:2 in 
  let _, x1 = x in 
  x1;;
Error: The value x has type a:int * b:int
       but an expression was expected of type 'a * 'b
       The first tuple element is labeled a,
       but an unlabeled element was expected

[samsa1]

As a whole I'm strongly in favor of this feature because I consider that it would increase the quality of life when handling tuples.

I also find the part about row-polymorphic tuples to be extremely interesting as it actually increases the expressiveness of OCaml's polymorphism. However I suspect this would require tweaking a few things in the back-end but hopefully not much.