> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # TypeScript Const Type Parameter A `const` type parameter is a modifier applied to a generic type parameter declaration that instructs the TypeScript compiler to infer the most specific literal type possible from a passed argument, rather than widening it to its base primitive or mutable type. By prefixing a generic parameter with the `const` keyword, you alter the compiler's default type inference algorithm for that specific generic context. ## Syntax The `const` modifier is placed directly before the type parameter name inside the angle brackets. It can be used standalone or combined with `extends` constraints. ```typescript theme={"dark"} // Standard const type parameter function extract(arg: T): T { return arg; } // Const type parameter with a constraint function extractArray(arg: T): T { return arg; } ``` ## Inference Mechanics When TypeScript resolves generic type arguments, its default behavior is to widen literal values to their base types to allow for mutability. The `const` modifier suppresses this widening process, applying a deep `readonly` inference model equivalent to appending an `as const` assertion at the call site. ### 1. Primitive Widening Without the modifier, literal primitives are widened. With the modifier, the exact literal type is preserved. ```typescript theme={"dark"} function standard(val: T) { return val; } function strict(val: T) { return val; } const a = standard("data"); // Inferred as: string const b = strict("data"); // Inferred as: "data" ``` ### 2. Object and Array Inference For structural types, the `const` modifier recursively applies `readonly` modifiers to all properties and infers arrays as `readonly` tuples. ```typescript theme={"dark"} const obj1 = standard({ id: 1, tags: ["a", "b"] }); // Inferred as: { id: number, tags: string[] } const obj2 = strict({ id: 1, tags: ["a", "b"] }); // Inferred as: { readonly id: 1, readonly tags: readonly ["a", "b"] } ``` ## Technical Constraints and Rules * **Call-Site Exclusivity:** The `const` modifier only affects types inferred from arguments passed at the call site. It has no effect on the internal implementation of the function or class. * **Explicit Type Arguments Override:** If a developer explicitly provides a type argument during invocation, the `const` modifier's inference rules are bypassed entirely. ```typescript theme={"dark"} // The explicit overrides the const literal inference const c = strict("data"); // Inferred as: string ``` * **Non-Literal Arguments:** If the argument passed is already a widened variable (e.g., a variable declared with `let`), the `const` type parameter cannot infer a literal type because the literal information has already been lost prior to the function call. ```typescript theme={"dark"} let dynamicValue = "data"; const d = strict(dynamicValue); // Inferred as: string ``` * **Class and Interface Generics:** The `const` modifier is only valid on type parameters for functions, methods, and classes where inference from arguments occurs. It cannot be used on interface or type alias declarations.

Tired of Poor TypeScript Skills? Fix That With Deep Grasping! Learn More