Question

我正在尝试键入一个函数，该函数带有一个将一系列项目减少为一个累加值的参数。这是我所拥有的简化：

// A stub type for the items
interface Item { t: 'item'; }

function paginate<A>(reduce: (acc: A, item: Item, index: number) => A): Promise<A> {
  // ... stub for actual implementation ...
  return true as unknown as Promise<A>;
}

如果调用此函数，则无法获得所需的推理类型。我希望当知道reduce的返回类型时，也应该将第一个参数（acc）推断为该类型。

// expected: Promise<number>, inferred: Promise<{}>
const result = paginate((acc, item, index) => {
  acc; // expected: number, inferred: {}
  item; // expected: Item, inferred: Item
  index; // expected number, inferred: number

  return 5;
});

我尝试使用带条件类型的推断来解决此问题，但是我尝试过的所有变体都失败了，因为它们没有将acc的通用类型参数约束为任何特定的参数，或者因为推断而失败了是递归的。我不太确定。

type Reducer<A> = (acc: A, item: Item, index: number) => A;
type Accumulator<Reduce> = Reduce extends (acc: infer A, item: Item, index: number) => infer A ? A : never;

// Probably too loose (using an any)
function paginateA<R extends Reducer<any>>(reduce: R): Promise<Accumulator<R>> {
  // ...
  return true as unknown as Promise<Accumulator<R>>;
}

// expected: Promise<number>, inferred: Promise<number>
const resultA = paginateA((acc, item, index) => {
  acc; // expected: number, inferred: any
  item; // expected: Item, inferred: Item
  index; // expected number, inferred: number

  return 5;
});

// Probably too recursive (tried to circuit-break with only inferring the return type first)
function paginateB<R extends Reducer<ReturnType<R>>>(reduce: R): Promise<Accumulator<R>> {
  // ...
  return true as unknown as Promise<Accumulator<R>>;
}

// expected: Promise<number>, inferred: Promise<any>
const resultB = paginateB((acc, item, index) => {
  acc; // expected: number, inferred: any
  item; // expected: Item, inferred: Item
  index; // expected number, inferred: number

  return 5;
});

是否有“断路”递归条件类型推断的技术？我看到了Anders mention that some class of recursive inference is okay（即使快速信息会将类型显示为any），但我无法理解这种情况的发生情况。

我还缺少其他一些技巧吗？ paginateA()似乎效果最好，因为至少它正确地选择了resultA的类型。有什么理由吗？

这里是playground with all the above code可以操纵。

Answer 1

正如我所说，我认为您要尝试从A进行的Reducer<A>的特殊推断可能会在TypeScript 3.4及更高版本中自动发生，但尚未发布。对于TypeScript 3.3及以下版本：

我想在这样的情况下使用过的特定技术

declare function f<T extends Something<T>>(x: T): void; // circularity error or other issue

是使通用T不受约束，并通过相交将约束放在函数参数上：

declare function f<T>(x: T & Something<T>): void; // works now

我找不到规范的文档，但是我认为这是可行的，是当您调用f(x)时，编译器会尝试从T类型的x推断出T & Something<T> {1}}。由于x是T & Something<T>，因此从交叉点的工作方式来看，它必须是T。因此，x参数的类型用作T。然后它将用Something<T>检查交叉点，如果这样不起作用，则会出现编译器错误。

让我们根据您的情况进行尝试，但是在我们这样做之前，有一个很大的警告：您可能无法使编译器都从传递的值中推断paginate()的{{1}}类型参数以R的形式输入，和从调用{{1} }。也就是说，reduce将被推断为reduce，但您将必须注释 R ... 或，您将必须指定 paginate()为R，编译器将推断 Reducer<number>的类型。您需要两种方式，但是我认为编译器不够聪明。或者至少我做不到。因此，我现在假设您正在尝试从完全注释的(acc:number, item:Item, index:number)回调中推断R：

Reducer<number>

很好。

备份推论acc, item, index的问题...您总是可以这样指定R：

reduce

但是您不想这样做。

实际上，我不希望编译器将interface Item { t: "item"; } type Reducer<A> = (acc: A, item: Item, index: number) => A; type Accumulator<Reduce> = Reduce extends Reducer<infer A> ? A : never; declare function paginateC<R extends Reducer<any>>( reduce: R & Reducer<ReturnType<R>> // intersection here ): Promise<Accumulator<R>>; // Promise<number> as desired const resultC = paginateC((acc: number, item: Item, index: number) => 5); // error, string is not number: paginateC((x: number, y: Item, z: number)=>"string"); // okay, since string is a subtype of unknown paginateC((x: unknown, y: Item, z: number)=>"string") // also works with any paginateC((x: any, y: Item, z: number)=>"string")参数缩小到您想要的acc, item, index，因为可以始终安全地扩展函数参数（contravariance of function parameters）。编译器可能会将R保留为// acc, item, index inferred from specified R paginateC<Reducer<number>>((acc, item, index) => 5);，acc或A之类的宽字体，除非您对其进行注释或如上所述手动指定acc。

我 am 有点惊讶，它没有将{}和unknown缩小到any和R而不是缩小它们为item。但是可能没有太多事情要做，因为它是类型推断的known limitation，它不会多次通过。哦，很好。

好的，希望能有所帮助。祝你好运！

TypeScript：有什么技术可以打破递归条件类型推断？

1 个答案: