[Haskell-cafe] Type Directed Name Resolution

[Richard O'Keefe]

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