Feature Request: Explicit destructuring function types

[ccorcos]

TypeScript Version: 2.5.2

Code

Most of the time Typescript does a great job inferring types so its possible to write a higher-order function with generic types representing the inputs and outputs a function. For example:

// Infers the inputs and outputs of a function
function f<X, Y>(fn: (x: X) => Y): (x: X) => Y {
	return fn
}

function g(x: number): string {
	return x.toString()
}

// result has type (x: number) => string as we'd expect
const result = f(g)

However, sometimes Typescript does not infer types well, such as #18807. In cases such as this, how are we supposed to explicitly define the generics of the function f?

The obvious example is f<number, string>(g) but that can be very tedious, especially the input type definition for g isn't defined separately and exported or if the output type of g is inferred.

A solution to this problem would be some way of destructuring the type of a function so I can pass typeof g as the generic argument to f like the following:

function f<(x:X) => Y>(fn: (x:X) => Y): (x: X) => Y {
	return fn
}

f<typeof g>(g)

[DanielRosenwasser]

@rbuckton has been experimenting with some stuff here, but I don't think we have a formal writeup/proposal I can point to yet.

[ccorcos]

Ok. It just seems weird that we can explicitly do the same that that the compiler can infer...

[mhegazy]

With conditional types you should be able to extract these types from the function, and no need for special destructuring operations.. e.g.:

f<ParamType<typeof g>, ReturnType<typeof g>>(g);

type ParamType<T> = T extends (a: infer A) => any ? A : never; 
type ReturnType<T extends (...args: any[]) => any> = T extends (...args: any[]) => infer R ? R : any;

[typescript-bot]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.