Higher order type inference doesn't work with overloads

[falsandtru]

Anders Hejlsberg (@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]

Anders Hejlsberg (@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]

Trey Brisbane (@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]

Anders Hejlsberg (@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.

[sylann]

I also hit this kind of issue semi-regularly, each time hoping that typescript will have fixed it by then :)

Here is my latest example, and I get this one pretty often.

export function optionMapper<In, Out>(f: (p: In) => Out): (v: null) => null
export function optionMapper<In, Out>(f: (p: In) => Out): (v: In) => Out
export function optionMapper<In, Out>(f: (p: In) => Out): (v: In | null) => Out | null
export function optionMapper<In, Out>(f: (p: In) => Out): (v: In | null) => Out | null {
 return (v) => v == null ? null : f(v)
}

// Example option mappers
export const fromApiDate = optionMapper((date: string) => new Date(date))
export const toApiDate = optionMapper((date: Date) => date.toJSON())

But fromApiDate and toApiDate are both just (null) => null.

Of course, there are several solutions to get around this issue.
But all these solutions involve more or less code duplication which I precisely want to avoid.

Would love to hear your thoughts on this, because I get a sense that I may have missed something obvious.

Full example available at www.typescriptlang.org/play