TypeScript 泛型类型参数是通过函数推断出来的，而不是类型？

Question

Consider this:

type SpecificKeys<T extends string> = {
  [key in T]: string;
};

const foobar: SpecificKeys<"foo" | "bar"> = {
  foo: "foo",
  bar: "bar",
};

I have to specify the union of the keys as the generic type argument when creating foobar , which is redundant. I can't figure any way around this. But if I write a do-nothing function:

function makeSpecificKeys<T extends string>(thing: SpecificKeys<T>): SpecificKeys<T> {
  return thing;
}

const foobarInferred = makeSpecificKeys({
  foo: "foo",
  bar: "bar",
});

then const foobarInferred is correctly typed as SpecificKeys<"foo" | "bar"> SpecificKeys<"foo" | "bar"> and I didn't have to repeat myself by enumerating all the keys.

Is there any way to achieve inference of a generic type parameter when creating a typed variable without having to make a do-nothing function?

Answer 1

Answer is no. Type restricts the value, saying a:T means value a needs to be a member of type T , if not - then compile error. What you want is to say a: infer me typeof a , so in other way round.

Type annotations is for restricting the value, not value to restrict the type. TS allows for taking type from the value, but it not allows for taking the type of the value and restricting it at once.

---

Still, we can make some tricks to make it working. Consider type level solution:

type SpecificKeys<T extends string> = {
  [key in T]: string;
};

// type level version of makeSpecificKeys
type MakeSpecificKeys<T extends SpecificKeys<string>> = T;

const foobar = {
  foo: "foo",
  bar: "bar",
};
type FoobarType = MakeSpecificKeys<typeof foobar> // fine 👌

const badfoobar = {
  foo: 1, // number value dont match SpecificKeys
  bar: "bar",
};
type BadFoobarType = MakeSpecificKeys<typeof badfoobar> // error 👌

The Playground

Both values foobar and badfoobar are inferred by TS properly without any type annotations. The next thing is calling type level MakeSpecificKeys which is kinda id function you have made before, but this one is at the type level, it restricts the argument type in the same way makeSpecificKeys was doing it. For the badfoobar it shows compile error.

What I have shown here is undoubtedly worst approach then value constructor makeSpecificKeys you have made. So stick to that. The one single point of using above approach is that nothing from it goes to the runtime, when makeSpecificKeys does.