联合函数类型的推断

Question

假设我有类似的架构：

type GetDog = () => { animal: string; bark: boolean };
const getDog: GetDog = () => ({ animal: 'dog', bark: true });

type GetCat = () => { animal: string; meow: boolean };
const getCat: GetCat = () => ({ animal: 'cat', meow: true });

type AnimalFactory =
  | ((callback: GetDog) => ReturnType<typeof getDog>)
  | ((callback: GetCat) => ReturnType<typeof getCat>);

const calmAnimalFactory: AnimalFactory = (callback) => {
  // Some fancy stuff
  return callback();
};

calmAnimalFactory 作为参数应该接受getDog 函数或getCat 函数，然后返回相应的值。问题是我猜类型推断不像我想象的那样工作。 calmAnimalFactory 内部的回调不会推断GetDog | GetCat 的类型，而是any。我认为 Typescript 应该确定 calmAnimalFactory 的类型，而 calmAnimalFactory(getDog) 应该输入为

((callback: GetDog) => ReturnType<typeof getDog>)

而calmAnimalFactory(getCat) 应输入为

((callback: GetCat) => ReturnType<typeof getCat>)

我希望有可能实现，但我不知道为什么它不能那样工作。

Answer 1

这里发生了一些事情。首先，我认为如果我必须继续输入typeof getXXX 或ReturnType<typeof getXXX>，我会发疯的，所以我将定义新的Dog 和Cat 接口对应于getDog() 和getCat() 返回的内容，并专门使用它们：

interface Dog extends ReturnType<GetDog> { };
interface Cat extends ReturnType<GetCat> { }

您可以并且可能应该首先定义这些Dog 和Cat 类型，然后根据它们编写getCat() 和getDog()：

interface Dog {
  animal: string;
  bark: boolean;
}

type GetDog = () => Dog;
const getDog: GetDog = () => ({ animal: 'dog', bark: true });

interface Cat {
  animal: string;
  meow: boolean;
}
type GetCat = () => Cat;
const getCat: GetCat = () => ({ animal: 'cat', meow: true });

但无论哪种方式都可以。

---

接下来，如果您希望 AnimalFactory 在传递 GetCat 参数时返回 Cat，并且您希望在传递 Dog 时返回 Dog GetDog 参数，那么您想使用 intersection (&) 而不是 union (|)。如果你使用工会，你是说动物工厂要么将GetCat变成Cat，要么 GetDog 变为 Dog，但不一定两者兼而有之。所以我们想要这里的交集：

type AnimalFactory =
  ((callback: GetDog) => Dog)
  & ((callback: GetCat) => Cat);

---

接下来，编译器无法很好地推断未注释和未断言的函数实现是否符合这种签名的交集。这样的推理相当于能够正确地对overloaded functions 进行类型检查，而编译器根本无法做到这一点（例如，请参阅microsoft/TypeScript#35338 中的this comment）。

因此，如果您只是尝试根据上下文键入 callback 参数，编译器将失败，并最终隐式使用 any，如您所见。

---

最好使用generic 函数实现，声称能够将() => T 类型的callback 用于泛型T extends Cat | Dog，然后生成T。这是编译器可以类型检查的东西：

const calmAnimalFactory: AnimalFactory =
  <T extends Cat | Dog>(callback: () => T) => {
    return callback();
  };

编译器能够验证<T extends Cat | Dog>(callback: () => T) => T 类型的函数是否可以分配给AnimalFactory 的两个调用签名，因此它编译时没有错误。

---

事实上，根据您的用例，您可能希望通过删除对Cat 和Dog 的依赖来使AnimalFactory 尽可能通用，而是提出一些基本类型，例如Animal，如：

interface Animal {
  animal: string;
}
type UniversalAnimalFactory = <T extends Animal>(callback: () => T) => T;
const universalAnimalFactory: UniversalAnimalFactory = callback => callback();

UniversalAnimalFactory 可以做任何 AnimalFactory 可以做的事情（GetCat in，Cat out；和 GetDog in，Dog out），但它也可以为您拥有的动物做任何其他事情'甚至还没有想到：

const getFish = () => ({ animal: "fish", swim: true });
universalAnimalFactory(getFish).swim // works

---

Playground link to code

Answer 2

您可以使用泛型对此进行正确输入。我们说calmAnimalFactory 依赖于代表回调类型的通用T。这个T 必须是一个接受零参数并返回任何内容的函数。

现在我们可以说calmAnimalFactory 的callback 参数是T，并且函数的返回类型与回调的返回类型相同。

const calmAnimalFactory = <T extends () => any>(callback: T): ReturnType<T> => {
  // Some fancy stuff
  return callback();
};

const dog = calmAnimalFactory(getDog); // type: { animal: string; bark: boolean; }
const cat = calmAnimalFactory(getCat); // type { animal: string; meow: boolean; }

相同想法的稍微不同的版本是让泛型T 指代所创建动物的类型。这使得要求回调的返回必须适合某个基本的Animal 接口变得更容易。

interface Animal {
  animal: string;
}

const calmAnimalFactory = <T extends Animal>(callback: () => T): T => {
  // Some fancy stuff
  return callback();
};

cat 和 dog 的类型仍然相同。

Typescript Playground Link