TypeScript 类型推断与泛型类型的交集

Question

我有一个用例，我有一个可组合对象，它应该（不）与某些功能一起使用，具体取决于它的组成部分。合成是使用类型交集完成的。

这是代码的简化版本：

type A<T> = { a: T }
type B<T> = { b: (val: T) => T }

const shouldWork = {
  a: 'str',
  b: (val: string) => val.toUpperCase(),
  someOtherProp: 'foo'
}

const shouldFail = {
  a: 'str',
  b: (val: number) => 42
}

function test<T extends A<???> & B<???>>(obj: T): T {
  return {
    ...obj,
    a: obj.b(obj.a)
  }
}

const res1 = test(shouldWork);
// res1 should be typeof shouldWork, i.e. A & B & { someOtherProp: string }
console.log(res1.a); // "STR"
console.log(res1.someOtherProp); // "foo"

const res2 = test(shouldFail); // should fail because A<string> and B<number> don't match

我尝试过使用test<T extends A<any> & B<any>>，但这当然允许任何泛型类型的组合。

然后我尝试添加一个额外的类型S 以确保两个泛型相同：test<S, T extends A<S> & B<S>>。但这会失败，因为 “参数类型 'val' 和 'val' 不兼容。类型 'unknown' 不能分配给类型 'string'”

经过多次尝试，我发现了一些可以按预期工作的东西：

function test<S, T extends A<S> & B<S> = A<S> & B<S>>(obj: T): T { ... }
const res1 = test<string>(shouldWork);
const res2 = test<string>(shouldFail); // throws error: Types of parameters 'val' and 'val' are incompatible. Type 'string' is not assignable to type 'number'

但正如您所见，它很难阅读，也很难写，尤其是当交集包含更多类型时。

有没有更简单的方法来完成这项工作？

Answer 1

这有点“不确定”，但实现您想要的推理的一种方法是这样的：

function test<O, T>(obj: O & A<T> & B<T>): O {
    return {
        ...obj,
        a: obj.b(obj.a)
    }
}

如果您希望编译器从对函数 func(param) 的调用中推断出类型参数 X，其中 param 的类型为 P，并且 func 的调用签名类似于 <X>(param: F<X>) => any，则编译器会将P 插入F<X> 以获取X 的候选对象。

如果调用签名涉及intersection type，如<X>(param: F<X> & G<X>) => void，编译器将倾向于将P插入两者 F<X> 和 G<X>获得候选人......即使只为其中一个人这样做是好的（有时是可取的）。

因此，对于调用签名<O, T>(obj: O & A<T> & B<T>) => O 的test(obj)，编译器将倾向于将O 与typeof obj 匹配以获取O 的候选对象，然后还将A<T> 和B<T> 匹配到@ 987654348@ 获取T 的候选人。如果obj 不是有效的A<T> & B<T>，则推理将失败。您可以使用O 来表示obj 的实际类型，而无需将其扩大到A<T> & B<T>。

所以这就是你想要的方式：

const res1 = test(shouldWork); // okay
const res2 = test(shouldFail); // error
// -------------> ~~~~~~~~~~
// Argument of type '{ a: string; b: (val: number) => number; }' is not assignable to
//  parameter of type '{ a: string; b: (val: number) => number; } & A<number> & B<number>'.

---

如果这不起作用，您可以通过使用单个不受约束的类型参数 O 并让参数 obj 成为 conditional type 来获得类似的行为：

function test<O>(obj: O extends (A<infer T> & B<infer T>) ? O : never): O {
    return {
        ...obj,
        a: obj.b(obj.a)
    }
}

const res1 = test(shouldWork); // okay
const res2 = test(shouldFail); // error\
// -------------> ~~~~~~~~~~
// Argument of type '{ a: string; b: (val: number) => number; }' \
// is not assignable to parameter of type 'never'

这是可行的，因为编译器倾向于将参数P 的类型插入到X extends ... 这样的条件类型中的参数X，因此typeof obj 是O 的候选对象，它然后检查A<infer T> & B<infer T>。如果找到有效的T，则obj 将再次与O 进行检查，这没有问题。如果未找到有效的T，则将针对never 检查obj，这可能不起作用。它有点复杂，但具有类似的行为（错误消息不太容易理解）。

---

至于为什么以下不起作用：

declare function test<O extends A<T> & B<T>, T>(obj: O): O;

问题在于T 没有推理站点。编译器可以使用typeof obj 推断O，但是当它检查T 时，它就卡住了。您可能期望编译器可以从O 的constraint A<T> & B<T> 推断出T，但一般约束不会以这种方式用作推断站点。请参阅microsoft/TypeScript#7234 以获取支持这一点的旧建议。他们没有实现这样的功能，而是suggested 人们完全按照我在此答案开头所做的方式从交叉路口推断。

无论如何，如果没有T 的推理站点，编译器就会退回到unknown。然后O 被限制为A<unknown> & B<unknown>，这不太可能奏效。所以一切都崩溃了。

Playground link to code