infer est utilisé dans un conditional type pour capturer (extraire) un type de l'intérieur d'un autre type dans une nouvelle variable de type que vous pouvez ensuite utiliser. C'est du pattern-matching pour les types.
<T> = T (infer U)[] ? U : ;
A = <[]>;
B = <[]>;
Lisez-le ainsi : « si T correspond au motif U[], liez U à quel que soit le type d'élément, et retournez-le. » infer U déclare un placeholder que le compilateur remplit par correspondance.
// the resolved type of a Promise
type Awaited2<T> = T extends Promise<infer R> ? R : T;
type R = Awaited2<Promise<User>>; // User
// a function's return type (this is how ReturnType is built)
type MyReturn<T> = T extends (...args: any[]) => infer R ? R : never;
type X = MyReturn<() => number>; // number
// a function's first parameter
type FirstArg<T> = T extends (a: infer A, ...rest: any[]) => any ? A : never;
type UnwrapBoth<T> =
T extends Promise<infer U> ? UnwrapBoth<U> : // recurse to unwrap nested promises
T extends (infer E)[] ? E : T;
Vous pouvez utiliser plusieurs infers dans un motif et même faire de la récursion.
infer est le moteur des types intégrés comme ReturnType, Parameters, Awaited et InstanceType, et derrière la magie des bibliothèques qui dérive les types de réponse des fetchers ou les props des composants.
Cela permet au code de type « d'ouvrir » un type complexe et d'en extraire les parties internes — l'outil le plus puissant pour écrire des types qui s'adaptent à d'autres types.