On 11/11/2010, at 10:33 PM, Gábor Lehel wrote:
I would have TDNR apply only in cases where: ... - The ambiguity can be resolved by looking at the type of the first (taking currying into account, only) parameter of each function and, looking at the type constructors from the outside in, comparing only type constructors which are concrete types, rather than type variables (with or without constraints).
This just feels so wrong. One of the joys of types in Haskell and of overloading in Ada is that it depends on *all* the arguments of a function *and* the result. I note that record field overloading can be put in a language without providing ad hoc polymorphism for any other functions. A little ML: Given type t1 = {a: int, b: string}; type t2 = {a: string, b: int}; val x1 : t1 = {a = 1, b = "2"}; val x2 : t2 = {b = 2, a = "1"}; this interaction followed: - (#a x1, #a x2, #b x1, #b x2); val it = (1,"1","2",2) : int * string * string * int Here we had #a : t1 -> int #b : t1 -> string #a : t2 -> string #b : t2 -> int The consequence is that when I see val N = #capacity derived () I don't know what capacity means for sure, but I *do* know that it is a record field, so I have some idea what to look for. It turns out that there are four possibilities but for two of them () would not be a legal argument, so there are only two possibilities. I note that there is a reason for having quite a few records in a module with many shared field names at different types, which I had not thought of. That is the practice of passing a record as a function's sole argument in order to get the effect of keyword arguments, fairly popular in SML: val max_flow : { graph : ('n,'e,'g) Graph.graph, s : Graph.node_id, t : Graph.node_id, capacity : 'e Graph.edge -> Num.elem, flows : 'e Graph.edge * Num.elem -> unit } -> Num.elem val min_cost_max_flow : { graph : ('n,'e,'g) Graph.graph, s : Graph.node_id, t : Graph.node_id, capacity : 'e Graph.edge -> Num.elem, cost : 'e Graph.edge -> Num.elem, flows : 'e Graph.edge * Num.elem -> unit } -> Num.elem There is no intention here to have lots of values of these record types. They are anonymous, after all. This case needs to be considered separately from other cases.
And, in any case, as a language extension nobody would be forced to use it if they don't like it.
Wrong. They would not be forced to use it in their own code, but they *WOULD* be forced to read it in other people's code. (Why so much focus on the writers and so little on the readers?)