type IsCapitalized = Capitalize; const test1: IsCapitalized = "Gamera3RevengeOfIris1999"; const test2: IsCapitalized = "theLastSeduction1994"; const test3: IsCapitalized = ""; type IsUppercased = Uppercase; const test4: IsUppercased = "Gamera3RevengeOfIris1999"; const test5: IsUppercased = "RRR2022"; const test6: IsUppercased = ""; type UppercaseLetters = { a: "A"; b: "B"; c: "C"; d: "D"; e: "E"; f: "F"; g: "G"; h: "H"; i: "I"; j: "J"; k: "K"; l: "L"; m: "M"; n: "N"; o: "O"; p: "P"; q: "Q"; r: "R"; s: "S"; t: "T"; u: "U"; v: "V"; w: "W"; x: "X"; y: "Y"; z: "Z"; }; type CustomCapitalize = S extends `${infer First}${infer Rest}` ? First extends keyof UppercaseLetters ? `${UppercaseLetters[First]}${Rest}` : S : S; type Movie1 = "Gamera3RevengeOfIris1999"; type Movie2 = "theLastSeduction1994"; type Movie3 = ""; type Capitalized1 = CustomCapitalize; type Capitalized2 = CustomCapitalize; type Capitalized3 = CustomCapitalize; type IsCustomCapitalized = CustomCapitalize; const testC1: IsCustomCapitalized<"Gamera3RevengeOfIris1999"> = "Gamera3RevengeOfIris1999"; const testC2: IsCustomCapitalized<"theLastSeduction1994"> = "theLastSeduction1994"; const testC3: IsCustomCapitalized<""> = ""; type CustomUppercase = S extends `${infer First}${infer Rest}` ? First extends keyof UppercaseLetters ? `${UppercaseLetters[First]}${CustomUppercase}` : `${First}${CustomUppercase}` : S; type Movie4 = "Gamera3Re308OfIris1999"; type Movie5 = "RRR2022"; type Movie6 = ""; type Uppercase1 = CustomUppercase; type Uppercase2 = CustomUppercase; type Uppercase3 = CustomUppercase; type IsCustomUppercased = CustomUppercase; const testU4: IsCustomUppercased<"Gamera3RevengeOfIris1999"> = "Gamera3RevengeOfIris1999"; const testU5: IsCustomUppercased<"RRR2022"> = "RRR2022"; const testU6: IsCustomUppercased<""> = ""; // Basic recursion type type ReverseString = S extends `${infer First}${infer Rest}` ? `${ReverseString}${First}` : S; type reversed1 = ReverseString<"Gamera3RevengeOfIris1999">; // Notes // TS infer takes the first char in the string and puts the rest under the second variable type Example = S extends `${infer First}${infer Rest}` ? First : never; // You can infer the next char just by adding a variable in the middle type FirstChar2 = S extends `${infer First}${infer Second}${infer Rest}` ? Second : never; // Standard infer usage // To better understand how infer works, let's take a look at the basic syntax of a conditional type: type MyConditionalType = T extends SomeType ? TrueType : FalseType; // In this example, T is a generic type parameter, and SomeType represents a type that T is being compared to. // If T extends SomeType, the type of MyConditionalType will be TrueType. If not, it will be FalseType. // Now, let’s introduce the infer keyword into the mix: type MyInferredType = T extends SomeType ? U : FalseType; // Here, we use the infer keyword to create a temporary type variable U within the true branch of the conditional type. // If T extends SomeType, TypeScript will try to infer the type of U based on the type of T. // ReturnType // ReturnType is a utility type that extracts the return type of a function. // It's a perfect example of how the infer keyword can be used to create dynamic types. Here's the definition of ReturnType: type ReturnType any> = T extends (...args: any[]) => infer R ? R : any; // In this definition, T is a function type that takes any number of arguments and returns any type. // Using the infer keyword, we create a temporary type variable R to represent the return type of the function. If T is a function, TypeScript infers the return type and assigns it to R. // Let’s see ReturnType in action: function greet(name: string): string { return `Hello, ${name}!`; } type GreetReturnType = ReturnType; // GreetReturnType is inferred as 'string' // Here, ReturnType is used to infer the return type of the greet function, which is string. // Parameters // Another useful utility type that leverages the infer keyword is Parameters. // This type extracts the parameter types of a function as a tuple. The definition of Parameters is as follows: type Parameters any> = T extends (...args: infer P) => any ? P : never; // In this example, we create a temporary type variable P to represent the parameter types of the function. // If T is a function, TypeScript infers the parameter types and assigns them to P as a tuple. // Let’s look at an example using Parameters: function add(a: number, b: number): number { return a + b; } type AddParameters = Parameters; // AddParameters is inferred as [number, number] // Here, Parameters is used to infer the parameter types of the add function, which is a tuple [number, number]. // PromiseType // The PromiseType utility type can be used to extract the type that a Promise resolves to. // This is particularly useful when dealing with asynchronous functions. Here's the definition of PromiseType: type PromiseType> = T extends Promise ? U : never; // In this example, we create a temporary type variable U to represent the type that the Promise resolves to. // If T is a Promise, TypeScript infers the resolved type and assigns it to U. Here’s an example: async function fetchData(): Promise { return "Fetched data"; } type FetchedDataType = PromiseType>; // FetchedDataType is inferred as 'string' // In this case, PromiseType is used to infer the type that the fetchData function's promise resolves to, which is string. // UnboxArray // The UnboxArray utility type can be used to extract the type of the elements within an array. Here's the definition of UnboxArray: type UnboxArray> = T extends Array ? U : never; // In this example, we create a temporary type variable U to represent the type of the elements within the array. // If T is an array, TypeScript infers the element type and assigns it to U. For instance: type MyArray = number[]; type ElementType = UnboxArray; // ElementType is inferred as 'number' // Here, UnboxArray is used to infer the type of elements within the MyArray type, which is number. // Limitations // It can only be used within conditional types. // It’s not always possible for TypeScript to infer the correct type, especially when dealing with complex or recursive types. // In such cases, developers may need to provide additional type annotations or refactor their types to help TypeScript infer the correct type.

jkbno