TypeScript
Inferencia de parámetros genéricos, valores por defecto y const type parameters para conservar literales y diseñar APIs con menos anotaciones explícitas.
function wrap<T>(value: T): { value: T } {
return { value };
}
const result = wrap("hello");
// { value: string }El literal puede ampliarse según el contexto y mutabilidad.
function pair<T>(first: T, second: T): [T, T] {
return [first, second];
}pair(1, 2);
// [number, number]pair(1, "two");Puede fallar porque el primer argumento conduce a una inferencia incompatible. Si quieres permitir mezcla, utiliza dos parámetros de tipo:
function pair<TFirst, TSecond>(
first: TFirst,
second: TSecond,
): [TFirst, TSecond] {
return [first, second];
}const loader: () => Promise<Product> =
async () => loadUnknownProduct();El contexto participa en la comprobación, pero no valida datos externos.
const empty = createCollection<Product>();Es útil cuando no hay argumento del cual inferir.
TypeScript no permite normalmente especificar algunos type arguments y dejar otros como placeholders arbitrarios.
function convert<TInput, TOutput>(value: TInput): TOutput;Diseña el orden de parámetros, defaults o una factory curried para permitir inferencia útil.
type ApiResponse<TData = unknown> = {
data: TData;
};const response: ApiResponse = {
data: externalValue,
};El default se usa cuando no existe un type argument explícito ni inferido.
Los parámetros requeridos no pueden aparecer después de uno opcional sin defaults adecuados.
type Result<TValue, TError = Error> =
| { ok: true; value: TValue }
| { ok: false; error: TError };type Collection<
TItem extends { id: string } = { id: string },
> = {
items: TItem[];
};El default debe cumplir el constraint.
function defineRoutes<const TRoutes extends readonly Route[]>(
routes: TRoutes,
): TRoutes {
return routes;
}const routes = defineRoutes([
{ path: "/", public: true },
{ path: "/admin", public: false },
]);const favorece inferencia literal y readonly para expresiones creadas en la llamada, similar a aplicar as const en el sitio apropiado.
function define<const T>(value: T): T {
return value;
}const type parameter solo cambia inferencia. No ejecuta Object.freeze.
function define<const T extends string[]>(value: T): T {
return value;
}Un array literal readonly inferido puede no cumplir string[], haciendo que TypeScript vuelva a un constraint más amplio. Usa un constraint readonly cuando quieres conservar literals:
function define<const T extends readonly string[]>(
value: T,
): T {
return value;
}NoInfer<T> bloquea una ubicación como fuente de inferencia sin cambiar el tipo final.
function createState<T>(
initialValue: T,
defaultValue?: NoInfer<T>,
): T {
return initialValue ?? defaultValue!;
}El tipo se infiere desde initialValue; defaultValue debe ajustarse a esa decisión en lugar de ampliarla.
function createFSM<TState extends string>(
states: readonly TState[],
initial: NoInfer<TState>,
) {}createFSM(
["idle", "loading", "success"] as const,
"idle",
);initial se comprueba contra la union derivada de states.
Cuando un type parameter aparece en parámetros de callback, retorno y valores, TypeScript reúne candidatos con reglas de variance y prioridad. Diseña APIs simples; no dependas de una inferencia misteriosa que solo funciona en un ejemplo.
function createValidator<T>() {
return <TValue extends T>(value: TValue): TValue => value;
}
const validateProduct = createValidator<Product>();Separa un type argument explícito de otros inferidos después.
function defineEvents<
const TEvents extends Record<string, unknown>,
>(events: TEvents): TEvents {
return events;
}
const events = defineEvents({
"product.created": {} as ProductCreated,
"product.deleted": {} as ProductDeleted,
});¿Por qué un const type parameter no reemplaza Object.freeze?
Porque solo conserva tipos literales y readonly durante el análisis; no añade ninguna operación al JavaScript emitido.
Interfaces, clases y factories genéricas aplica parámetros de tipo a contratos reutilizables y construcción.