Typescript partial type inference

Question

I am stumped by this and cannot figure out how to do this without a second function:

interface Fixed { a: number }
const fn = <A, B extends {} = {}>(b: B) => {
  return b
}

fn({ a: 1 }) // { a: number }
fn<Fixed>({ a: 1 }) // {}

const fn2 = <A>() => <B extends {} = {}>(b: B) => {
  return b
}

const result = fn2<Fixed>()({ a: 1 }) // { a: number }

Why does Typescript not infer the type of B if I fix type A? If I return a function that in turn tries to infer the type of B everything works again.

What is it you're trying to do? You have a lot of declared but unused type parameters — Aron
– Aron, Commented Aug 31, 2020 at 21:23
If you specify one parameter the other will not be inferred (the default will always be used). There is no partial inference support (some was planned never happened). The two function solution you found is the way to go. — Titian Cernicova-Dragomir
– Titian Cernicova-Dragomir, Commented Aug 31, 2020 at 21:57
@Aron: There is more code to it, I just liked to know why I could not let one part of the generic types be inferred without stacking two functions. — Nox
– Nox, Commented Sep 1, 2020 at 8:02
@TitianCernicova-Dragomir Thank you, in the answer below was a nice github issue exactly discussing my problems with this. — Nox
– Nox, Commented Sep 1, 2020 at 8:03

Mate Solymosi · Accepted Answer · 2020-08-31 22:05:17Z

28

Type inference works based on an all or nothing principle. In the first case:

fn({ a: 1 })

has no generic type parameters provided so it will infer both:

B will be inferred as { a: number } based on the function argument;
and A will be inferred as unknown since it's not used anywhere in the function.

In the second case:

fn<Fixed>({ a: 1 })

you have specified one of the generic types and that unfortunately means that type inference will not be used for the rest of the type parameters – therefore:

A is specified as Fixed;
B is not given so instead of inferring it it will default to {}.

As annoying as this is, it is just how TypeScript works. Your second example with two function calls is the usual workaround to this issue.

Related issue on GitHub.

answered Aug 31, 2020 at 22:05

Mate Solymosi

6,00726 silver badges31 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Nox Over a year ago

Thank you, I did not find that issue during my search. I'd love to get this changed, in my mind I still think that typescript should easily do this... But here we go stacking functions again.

Eliav Louski Over a year ago

any workaround with a single function call?

Mate Solymosi Over a year ago

None that I know of unfortunately :(

jorge Godoy · Accepted Answer · 2023-04-16 16:31:44Z

4

Another workaround is to pass a second argument just for type inference. The trick is to cast {} to the desired value:

interface Fixed { a: number }
const fn = <A, B extends {} = {}>(b: B, _param_just_for_type_inference: A) => {
  return b
}

fn({ a: 1 }, {} as Fixed)
/*
const fn: <Fixed, {
    a: number;
}>(b: {
    a: number;
}, _param_just_for_type_inference: Fixed) => {
    a: number;
}
*/

answered Apr 16, 2023 at 16:31

jorge Godoy

4914 silver badges4 bronze badges

Comments

Yamiteru XYZ · Accepted Answer · 2021-08-09 14:56:38Z

2

I believe currying is the solution. Just a general example:

const x = <I>(v: I) => <O>((v: I) => O) => O

// fully typed
x<number>(10)<string>((n) => `${n * 2}`);

// partial inference NO.1
x(10)<string>((n) => `${n * 2}`);

// partial inference NO.2
x<number>(10)((n) => `${n * 2}`);

// full inference
x(10)((n) => `${n * 2}`);

answered Aug 9, 2021 at 14:56

Yamiteru XYZ

15110 bronze badges

Collectives™ on Stack Overflow

Typescript partial type inference

3 Answers 3

3 Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

3 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related