Re: [Caml-list] Robust left to right flow for record disambiguation

[Jacques Garrigue <garrigue@math.nagoya-u.ac.jp>]

On 2013/10/24, at 5:52, Bob Zhang <bobzhang1988@gmail.com> wrote:

>    Record disambiguation is a practical feature, it helps a lot in
> writing open-free code.
>    In practice, I found it is a bit limited, below is two scenarios
> that the compiler can not infer in a correct way, will this be
> improved in the future by any chance?
>     From the user's point of view, annotating the toplevel is quite
> acceptable, maybe the typechecker could take the type-annotation as a
> higher priority.
>    ---
>    1.
>         let f (ls:t) =
>            ls |> List.map (fun x -> x.loc) (* cannot inferred x.loc*)
>   2.
>        type t = {loc:string}
>        type v = {loc:string; x:int}
>        type u = [`Key of t]
>        let f (u:t) =
>          match u with
>          | `Key {loc} -> loc (* does not compile *)

Case 1 would require a new specification of how type propagation works.
In particular, propagating from an argument to another argument.
For this reason, the probability that it gets done is low.
(I know that F# handles this case in a special way, but do we want to introduce
a special case just for |> ?)

Case 2 seems more reasonable (after replacing (u:t) by (u:u)).
In particular,
   let f (u:u) =
        match u with `Key loc -> loc.loc
already works, so it seems strange that the pattern-matching version doesn't.

	Jacques