Comment by Jeremy Lew (JIRA)

The ambiguity seems to be between the single-argument overload:
func resolve<T,Arg1>(f: (Arg1) -> T)
...and all of the higher-arity overloads. e.g.:

func resolve<T,Arg1,Arg2>(f: (Arg1,Arg2) -> T)

My uninformed opinion is that there must be some kind of "tuple splatting" (perhaps not the correct term) going on which tries to interpret any higher-arity function argument a funcition with a single argument with a higher-arity tuple type.

For example:
func(x,y,z) becomes func((x,y,z)) and therefore matches both the 3-arg type and the 1-arg type, hence the ambiguity. I think it needs to consider the "exact match" case (if one exists) to take priority over the "auto-splatted" case, but perhaps there are other scenarios where it wouldn't be able to make a judgement like that.

It seems bugs like these are just to haunt us forever... There is indeed splatting going on in the solver which shouldn't be, in `resolve(f: nullary)` for example, solver deduces solutions with `((())) -> ()` and `() -> ()` arguments, where the first one comes from `resolve<T, Arg1>`.

Comment by Jeremy Lew (JIRA)

Changing the signatures to accommodate for the implicit splat clears this up, at least for this example:

(e.g. f: (Arg1,Arg2) -> T becomes f: ((Arg1,Arg2)) -> T

enum Err: Error {
    case notimpl
}
func resolve<T>(type: T.Type) throws -> T {
    throw Err.notimpl
}

// This overload is no longer needed, nullary matches the unary tuple below
//func resolve<T>(f: () -> T) throws -> T {
//    throw Err.notimpl
//}

// Matches nullary and unary
func resolve<T,Arg1>(f: ((Arg1)) -> T) throws -> T {
    return f(try resolve(type:Arg1.self))
}
func resolve<T,Arg1,Arg2>(f: ((Arg1,Arg2)) -> T) throws -> T {
    return f((try resolve(type:Arg1.self), try resolve(type:Arg2.self)))
}
func resolve<T,Arg1,Arg2,Arg3>(f: ((Arg1,Arg2,Arg3)) -> T) throws -> T {
    return f((try resolve(type:Arg1.self), try resolve(type:Arg2.self), try resolve(type:Arg3.self)))
}

func nullary() {}
func unary(x:Int) {}
func binary(x:Int, y:Int) {}
func ternary(x:Int, y:Int, z:Int) {}

func no_longer_broken() {
    do {
        // All of these compile now.
        try resolve(f: nullary)  
        try resolve(f: unary)
        try resolve(f: binary) 
        try resolve(f: ternary) 
    }catch{
    }
}