Definición de constructores de tipos
Codifique constructores de tipos mediante consultas a interfaces.
Definición de constructores de tipos es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 4 lecciones en total.
Nombrar constructores de tipos
La codificación comienza asignando a cada constructor de tipos un identificador de cadena único llamado URI. La URI es una etiqueta que representa al constructor allí donde no podemos pasar el constructor directamente.
type ArrayURI = "Array";
type OptionURI = "Option";
// Each container gets a unique string tagUna interfaz de registro
Mantenemos una única interfaz que asigna cada URI al tipo concreto que produce para un argumento dado A. Esta interfaz es el registro. Cada clave es una URI; cada valor es el tipo resuelto.
interface URItoKind<A> {
Array: Array<A>;
Option: A | null;
}
// URItoKind<number>["Array"] is number[]Buscar un constructor
Como el registro utiliza las URI como claves, aplicar un constructor se convierte en un acceso indexado. Para obtener «Array aplicado a number», se indexa el registro.
type ArrayOfNumber = URItoKind<number>["Array"]; // number[]
type OptionOfString = URItoKind<string>["Option"]; // string | nullLa unión URIS
El conjunto de etiquetas de constructor válidas son simplemente las claves del registro. keyof URItoKind<unknown> proporciona la unión de todas las URI registradas, que denominamos URIS.
type URIS = keyof URItoKind<unknown>; // "Array" | "Option"La fusión de declaraciones amplía el registro
Una potente característica de TypeScript: las interfaces con el mismo nombre se fusionan. Las bibliotecas utilizan esto para que cada módulo pueda añadir su propio contenedor a URItoKind sin editar la definición original.
interface URItoKind<A> {
Tree: { value: A; children: Array<A> };
}
// Now URIS also includes "Tree"Contenedores modulares
Gracias a la fusión, un contenedor definido en un archivo se registra globalmente. Cualquiera que lo importe puede utilizar su URI en abstracciones genéricas. Así es exactamente como fp-ts añade Option, Either, Task y otros tipos.
// file a.ts
interface URItoKind<A> { Either: { left: A } | { right: A } }
// file b.ts can now reference the "Either" URIUn portador fantasma
Para transportar «qué constructor» como un tipo a nivel de valor, las instancias incluyen su URI en una propiedad, normalmente un campo fantasma. El campo nunca contiene un valor real; solo registra la etiqueta para el sistema de tipos.
interface HasURI<F extends URIS> {
readonly _URI: F;
}
// _URI records which constructor an instance is forAsociar la URI con el argumento
La aplicación de un constructor necesita dos elementos: la URI F y el tipo de argumento A. Los combinaremos mediante una búsqueda para que (F, A) se resuelva en el tipo concreto a través del registro.
type Apply<F extends URIS, A> = URItoKind<A>[F];
type A = Apply<"Array", number>; // number[]
type B = Apply<"Option", string>; // string | nullPor qué cadenas y no constructores
Usamos cadenas porque TypeScript puede almacenarlas y compararlas como tipos literales, además de indexar un registro con ellas. No podemos almacenar el constructor Array como parámetro de tipo, pero sí podemos almacenar el literal "Array" y buscarlo.
type Tag = "Array";
type Resolved = URItoKind<boolean>[Tag]; // boolean[]La búsqueda es el paso clave
Este acceso indexado, URItoKind<A>[F], es el núcleo de la codificación. Convierte una aplicación de tipos imposible, F<A>, en una búsqueda válida en el registro. La próxima lección lo formaliza como Kind<F, A>.
type Kind<F extends URIS, A> = URItoKind<A>[F];
type X = Kind<"Array", number>; // number[]Repaso de la configuración
Ya cuenta con todas las piezas: las URI como etiquetas, un registro URItoKind que asigna una etiqueta más un argumento a un tipo concreto, URIS como unión de las etiquetas y la fusión de declaraciones para ampliarlo. Indexar el registro simula la aplicación de tipos.
// URItoKind = registry, URIS = valid tags,
// URItoKind<A>[F] = "apply constructor F to A"Comprobación rápida
Compruebe su comprensión de la codificación mediante registros.
Repaso
Ha aprendido a codificar constructores de tipos con cadenas.
- Cada constructor recibe una etiqueta URI única.
URItoKind<A>asigna etiquetas a tipos concretos.URISes la unión de todas las etiquetas mediantekeyof.- La fusión de declaraciones permite a los módulos registrar nuevos contenedores.
A continuación: encapsular la búsqueda en el patrón ligero Kind.
Preguntas frecuentes
¿La lección «Definición de constructores de tipos» es gratis?
Sí — el texto completo de «Definición de constructores de tipos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Definición de constructores de tipos»?
Codifique constructores de tipos mediante consultas a interfaces. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar TypeScript Academy?
No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Definición de constructores de tipos»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?
Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- El problema de HKT en TypeScript
- Definición de constructores de tipos
- El patrón HKT ligero
- Functors y mappers genéricos