infer का उपयोग एक conditional type के अंदर किसी दूसरे type के भीतर से एक type को कैप्चर (निकालने) के लिए किया जाता है और उसे एक नए type variable में डालता है जिसे आप फिर इस्तेमाल कर सकते हैं। यह types के लिए pattern-matching है।
<T> = T (infer U)[] ? U : ;
A = <[]>;
B = <[]>;
इसे ऐसे पढ़ें: "अगर T, पैटर्न U[] से मेल खाता है, तो U को जो भी element type है उससे bind करें, और उसे return करें।" infer U एक placeholder घोषित करता है जिसे compiler मिलान करके भरता है।
// 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;
आप एक ही पैटर्न में कई infer का उपयोग कर सकते हैं और recurse भी कर सकते हैं।
infer, ReturnType, Parameters, Awaited, और InstanceType जैसे built-in types के पीछे का engine है, और उस library magic के पीछे भी जो fetchers से response types या components से props derive करती है।
यह type code को एक जटिल type को "खोलने" और भीतरी हिस्सों को बाहर निकालने देता है — ऐसे types लिखने के लिए सबसे शक्तिशाली टूल जो दूसरे types के अनुसार ढल जाते हैं।