Higher order type inference doesn't work with overloads

[falsandtru]

@ahejlsberg

TypeScript Version: typescript@3.7.0-dev.20190925

Search Terms:

Code

interface Curried2<a, b, z> {
  (a: a, b: b): z;
  (a: a): (b: b) => z;
}
interface Curry {
  <a, b, z>(f: (a: a, b: b) => z): Curried2<a, b, z>;
}

declare const curry: Curry;

curry(<T extends 0, U extends 1>(n: T, m: U) => n + m)(1)(0);
curry(<T extends 0, U extends 1>(n: T, m: U) => n + m)(1, 0);

Also the following doesn't work:

interface Curried2<a, b, z> {
  (a: a): (b: b) => z;
  (a: a, b: b): z;
}

When removing overloads as follows:

interface Curried2<a, b, z> {
  (a: a, b: b): z;
}

or

interface Curried2<a, b, z> {
  (a: a): (b: b) => z;
}

These work correctly.

Expected behavior:

Infer type parameters correctly and all parameter values are rejected correctly.

Actual behavior:

no error.

Playground Link:

Related Issues:

[RyanCavanaugh]

@ahejlsberg can you comment? I'm not 100% sure on this one

[ahejlsberg]

This is indeed a known design limitation. From #30215:

When an argument expression in a function call is of a generic function type, the type parameters of that function type are propagated onto the result type of the call if:

• the called function is a generic function that returns a function type with a single call signature,
  ...

We can mark this as a suggestion to support more than one signature in the result function type. It's possible to do, but not trivial.

[treybrisbane]

Just got hit by this while trying to describe the notion of a generic callable class:

class Foo<T> {
  constructor(readonly value: T) {}
}

function callable<P extends readonly any[], R>(Constructor: new (...params: P) => R): typeof Constructor & ((...params: P) => R) {
  return function (...params) {
    return new Constructor(...params);
  } as typeof Constructor & ((...params: P) => R);
}

const CallableFoo = callable(Foo);
// => (new (value: any) => Foo<any>) & ((value: any) => Foo<any>)
// Should be: (new <T>(value: T) => Foo<T>) & (<T>(value: T) => Foo<T>)

const foo1 = CallableFoo(42);
// => Foo<any>
// Should be: Foo<number>

const foo2 = new CallableFoo(42);
// => Foo<any>
// Should be: Foo<number>

[ahejlsberg]

@treybrisbane Why not just the following?

function callable<A extends readonly any[], R>(ctor: new (...args: A) => R): (...args: A) => R {
  return (...args) => new ctor(...args);
}

[treybrisbane]

@ahejlsberg In my case I'm trying to enable types to be both instantiable via new and callable. 🙂

I believe I can work around it. I just figured I'd leave a comment anyway, as I found it confusing that the higher-order inference didn't kick in given that my two overloads are identical in terms of parameters and result.