TypeScript infer y Tipado Condicional: De Junior a Senior en 11 minutos

👉 Ver en YouTube

Muchos desarrolladores usan TypeScript como si fuera solo una capa de anotaciones.

Agregan unas cuantas interfaces, tipan algunos parámetros, resuelven un error del compilador y siguen adelante.

Pero este video plantea algo mucho más interesante: TypeScript no es solo una lista de validaciones estáticas. Es un sistema de tipos capaz de inspeccionar, transformar y derivar información a partir de otros tipos.

Ahí es donde el tipado condicional y infer empiezan a importar de verdad.

TypeScript puede hacer más que describir valores

La idea central del video es simple.

No siempre necesitas escribir el tipo final a mano.

A veces, el tipo que buscas ya está escondido dentro de otro tipo y TypeScript puede extraerlo por ti.

Justamente para eso sirven los tipos condicionales.

type Resultado<T> = T extends string ? "texto" : "otro";

Esto se parece a un if, pero aplicado a tipos.

Si T coincide con una forma, TypeScript devuelve una rama. Si no coincide, devuelve la otra.

Parece algo pequeño, pero cambia la forma en que diseñas tus APIs.

Por qué los tipos condicionales importan en código real

Sin tipos condicionales, muchas APIs terminan siendo repetitivas, sobrecargadas o llenas de aserciones débiles.

Eso suele producir código que:

• repite la misma intención en varios lugares
• pierde precisión a medida que aparecen más casos
• recurre a any o as cuando todo se complica
• dificulta el trabajo del autocompletado

Los tipos condicionales permiten expresar de forma directa la relación entre el tipo de entrada y el tipo de salida.

Eso no es solo comodidad.

Es una forma de mover el contrato al sistema de tipos en vez de dejarlo únicamente en la cabeza del desarrollador.

infer extrae justo la parte que necesitas

El verdadero salto del video aparece cuando entra infer.

infer permite que TypeScript introduzca una variable de tipo temporal mientras intenta hacer coincidir una estructura.

Por ejemplo, si quieres obtener el tipo de los elementos de un arreglo, puedes escribir esto:

type ElementoDe<T> = T extends Array<infer Item> ? Item : T;

type A = ElementoDe<string[]>; // string
type B = ElementoDe<number>; // number

Aquí se ve con claridad por qué infer resulta tan útil.

Ya no estás indexando manualmente un tipo ni intentando recordar cómo extraer cada caso. Le estás pidiendo a TypeScript que observe la estructura y obtenga la pieza que falta.

Eso hace que los utility types sean más legibles y más reutilizables.

El ejemplo del factory muestra el verdadero valor

Una de las ideas más útiles del video es el ejemplo de estado/factory.

La función recibe una entrada que identifica una variante, y el tipo de retorno debería corresponder exactamente a esa variante.

Esto importa porque muchos proyectos empiezan con una unión amplia y terminan devolviendo algo demasiado genérico.

Entonces quien consume la función tiene que volver a hacer narrowing manualmente.

Con tipos condicionales, puedes modelar esa relación para que la función devuelva la forma específica asociada al tipo de entrada.

Eso te da:

• autocompletado más preciso
• menos aserciones manuales
• factories y helpers más limpios
• APIs que conservan la intención en lugar de borrarla

Aquí es donde TypeScript deja de sentirse decorativo.

Empieza a ayudarte a modelar comportamiento.

infer no es magia por sí solo

Solo funciona dentro de un tipo condicional, y funciona mejor cuando ya entiendes la estructura que estás intentando comparar.

Por eso la progresión del video tiene tanto sentido:

1. entender T extends X ? Y : Z
2. identificar la parte oculta del tipo que quieres extraer
3. usar infer para capturar esa parte
4. reutilizar el resultado en un contrato más limpio

Cuando lo ves así, infer deja de parecer algo misterioso.

Se convierte en una forma de pattern matching a nivel de tipos.

Una expansión útil: arreglos, promesas y funciones

El video se concentra en ejemplos con arreglos y factories, pero la misma idea aparece por todos lados en TypeScript moderno.

Con promesas:

type DesenvolverPromesa<T> =
  T extends Promise<infer U> ? U : T;

type Datos = DesenvolverPromesa<Promise<{ id: string }>>;
// { id: string }

Con funciones:

type ObtenerRetorno<T> = T extends (
  ...args: never[]
) => infer R
  ? R
  : never;

type Salida = ObtenerRetorno<() => { ok: true }>;
// { ok: true }

Esto no es un truco raro. Es la misma idea detrás de helpers integrados como ReturnType y Awaited.

Y eso importa porque demuestra que infer no es una rareza.

Es parte de la forma en que el propio TypeScript modela patrones comunes.

Los tipos condicionales distributivos son donde esto se afila

Un concepto que vale la pena ampliar más allá del video es la distribución sobre uniones.

Cuando un tipo condicional recibe una unión, TypeScript suele aplicar la condición a cada miembro por separado.

type AArreglo<T> = T extends any ? T[] : never;

type Resultado = AArreglo<string | number>;
// string[] | number[]

Ese comportamiento suele ser útil, pero también puede tomarte por sorpresa.

Es una de las razones por las que algunos utility types avanzados parecen más difíciles de lo que su sintaxis sugiere.

Así que, si alguna vez infer te parece inconsistente, es muy probable que el concepto que falta sea el de tipos condicionales distributivos.

Cuándo infer es la herramienta correcta

infer funciona especialmente bien cuando:

• el tipo ya contiene la información que necesitas
• quieres mantener una sola fuente de verdad
• un helper debe adaptarse a varias formas relacionadas
• la alternativa sería inflar overloads o repetir tipos a mano

Es ideal para arreglos, promesas, firmas de funciones, payloads de eventos, uniones discriminadas y helpers de biblioteca reutilizables.

Cuándo no conviene usarlo

No todos los problemas de tipado necesitan infer.

A veces un generic simple es más claro.

A veces una unión explícita es más honesta.

A veces un overload comunica mejor la intención que un tipo demasiado rebuscado.

Esa es la verdadera prueba de madurez.

TypeScript avanzado no consiste en escribir el tipo más ingenioso.

Consiste en elegir el contrato más legible que, al mismo tiempo, siga protegiendo el código.

Si infer elimina duplicación y conserva significado, está cumpliendo su función. Si vuelve ilegible una API sencilla, probablemente sea la abstracción equivocada.

El takeaway

La lección más importante de este video no es solo que infer sea poderoso.

Es que TypeScript puede derivar mucho más de lo que la mayoría de desarrolladores le pide.

Los tipos condicionales permiten expresar relaciones.

infer permite extraer la pieza faltante dentro de esas relaciones.

Juntos te ayudan a construir código:

• más preciso
• más reutilizable
• más seguro de evolucionar
• menos dependiente de any y de aserciones inseguras

Ahí es donde empieza el salto entre tipar por obligación y diseñar tipos con intención.