Better implicit function expression

[KSXGitHub]

Search Terms

Suggestion

Given this code:

const foo = x => bar(x)

Currently, it is translated to:

const foo = (x: any) => bar(x)

But I think this would be better:

declare function bar<T> (x: T): Result
const foo = <T0>(x: T0) => bar(x)

declare function bar (x: Param): Result
const foo = (x: Param) => bar(x)

Use Cases

When bar is generic

declare function bar<A, B, C, R> (a: A, b: B, ...rest: C[]): R
const foo = (a, b, c, d) => bar(a, b, c, d)

Should be converted to:

declare function bar<A, B, C, R> (a: A, b: B, ...rest: C[]): R
const foo = <T0, T1, T2>(a: T0, b: T1, c: T2, d: T2) => bar(a, b, c, d)

When bar isn't generic

declare function bar (a: A, b: B, ...rest: Rest[]): Result
const foo = (a, b, c, d) => bar(a, b, c, d)

Should be converted to:

declare function bar (a: A, b: B, ...rest: Rest[]): Result
const foo = (a: A, b: B, c: Rest, d: Rest) => bar(a, b, c, d)

When some parameters are irrelevant

Use any

const foo = (a, b) => b

Should be converted to:

const foo = <T0>(a: any, b: T0) => b

Examples

x => x wouldn't return any

const fn = x => x
const x = 123
const y: number = fn(x)

x => [x] wouldn't return any[]

const fn = x => [x]
const x = 123
const y: number[] = fn(x)

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript / JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. new expression-level syntax)

[kitsonk]

Your assumption is that the initial argument type infers the return of the function. That is not a valid assumption. For example, the following is totally valid:

const fn = x => 2;

But the type of x is irrelevant.

What about:

const fn = (x, y) => y;

Again, totally valid.

There simply is not sufficient information to reliably infer a return type for functions authored this way. TypeScript is good, but it cannot read minds of the developers (yet).

[KSXGitHub]

@kitsonk Simple, just make x: any.

Your assumption is that the initial argument type infers the return of the function

Actually, my assumption is that initial arguments will be used (x is passed to bar in my code snippets).

[DanielRosenwasser]

Looks like a duplicate of #17428 and #14078.

[DanielRosenwasser]

Actually, looking a little closer, it seems more like this is an ask for non-local type inference, not making unannotated functions generic.

[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.