Overloads without type specifications?

[dylex]

I'm not sure whether this is expected to work, but I thought it was:

-- count :: Int -> Int
count x = x

length :: List a -> Int
length = ...

-- count :: List a -> Int
count x = length x

With the type specifications, this is fine because unify gives the right answer. Without them, both are a -> b, which means count 1 is ambiguous and we never try either of them. It seems like we could make this work by attempting an entire inference pass on all possibilities in this case, but maybe we don't want to?

[girving]

Hmm. There are two possible issues that I see. First, if they both worked, there would be no way to know if they're specializations of each other, so we'd have to declare it ambiguous. That seems fine, though.

Next, it would make overload decisions involve more backtracking, which makes it even harder for the programmer to read the code and understand what's going on. In particular, code errors could silently result in the wrong overload being called. However, similar arguments apply to unoverloaded functions with no type specifications, and adding the type specifications back solves the problem if the programmer has any trouble.

Therefore, this might be something we want to do. Let's leave it as a proposal for a while and see if we like it later. In particular, it'd be good to know how hard it is to improve the error messages resulting from backtracking in the case we already have before adding another source of backtracking.