TypeScript Academy · Aula

Definindo Construtores de Tipos

Codifique construtores de tipos como consultas em interfaces.

Definindo Construtores de Tipos é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.

Nomeando Construtores de Tipos

A codificação começa atribuindo a cada construtor de tipos um identificador exclusivo de cadeia de caracteres chamado URI. A URI é um rótulo que representa o construtor sempre que não podemos passar o próprio construtor.

type ArrayURI = "Array";
type OptionURI = "Option";
// Each container gets a unique string tag

Uma Interface de Registro

Mantemos uma única interface que mapeia cada URI para o tipo concreto que ela produz para um determinado argumento A. Essa interface é o registro. Cada chave é uma URI; cada valor é o tipo resolvido.

interface URItoKind<A> {
  Array: Array<A>;
  Option: A | null;
}
// URItoKind<number>["Array"] is number[]

Consultando um Construtor

Como o registro é indexado por URI, aplicar um construtor se torna um acesso indexado. Para obter "vetor aplicado a número", você indexa o registro.

type ArrayOfNumber = URItoKind<number>["Array"]; // number[]
type OptionOfString = URItoKind<string>["Option"]; // string | null

A União URIS

O conjunto de rótulos de construtores válidos é simplesmente o conjunto de chaves do registro. keyof URItoKind<unknown> fornece a união de todas as URIS registradas, que chamamos de URIS.

type URIS = keyof URItoKind<unknown>; // "Array" | "Option"

A Fusão de Declarações Estende o Registro

Uma funcionalidade poderosa do TypeScript: interfaces com o mesmo nome se fundem. As bibliotecas usam isso para que cada módulo possa adicionar seu próprio contêiner a URItoKind sem editar a definição original.

interface URItoKind<A> {
  Tree: { value: A; children: Array<A> };
}
// Now URIS also includes "Tree"

Contêineres Modulares

Graças à fusão, um contêiner definido em um arquivo registra-se globalmente. Qualquer pessoa que o importe pode usar sua URI em abstrações genéricas. É exatamente assim que o fp-ts adiciona opção, resultado, tarefa e outros contêineres.

// file a.ts
interface URItoKind<A> { Either: { left: A } | { right: A } }
// file b.ts can now reference the "Either" URI

Um Transportador Fantasma

Para transportar a informação de "qual construtor" como um tipo no nível de valores, as instâncias carregam sua URI em uma propriedade, geralmente um campo fantasma. O campo nunca contém um valor real; ele apenas registra o rótulo para o sistema de tipos.

interface HasURI<F extends URIS> {
  readonly _URI: F;
}
// _URI records which constructor an instance is for

Combinando URI e Argumento

Uma aplicação de construtor precisa de duas coisas: a URI F e o tipo do argumento A. Vamos combiná-los com uma consulta para que (F, A) seja resolvido para o tipo concreto por meio do registro.

type Apply<F extends URIS, A> = URItoKind<A>[F];

type A = Apply<"Array", number>;  // number[]
type B = Apply<"Option", string>; // string | null

Por Que Cadeias de Caracteres, Não Construtores

Usamos cadeias de caracteres porque o TypeScript pode armazená-las e compará-las como tipos literais e indexar um registro com elas. Não podemos armazenar o construtor Array como um parâmetro de tipo, mas podemos armazenar o literal "Array" e consultá-lo.

type Tag = "Array";
type Resolved = URItoKind<boolean>[Tag]; // boolean[]

A Consulta É a Operação Principal

Esse acesso indexado, URItoKind<A>[F], é o centro da codificação. Ele transforma uma aplicação de tipos impossível, F<A>, em uma consulta válida ao registro. A próxima lição a formaliza como Kind<F, A>.

type Kind<F extends URIS, A> = URItoKind<A>[F];

type X = Kind<"Array", number>; // number[]

Recapitulação da Configuração

Agora você tem as peças: URIS como rótulos, um registro URItoKind que mapeia o rótulo e o argumento para um tipo concreto, URIS como a união dos rótulos e a fusão de declarações para estendê-lo. Indexar o registro simula a aplicação de tipos.

// URItoKind = registry, URIS = valid tags,
// URItoKind<A>[F] = "apply constructor F to A"

Verificação Rápida

Teste sua compreensão da codificação com registro.

Recapitulação

Você aprendeu a codificar construtores de tipos com cadeias de caracteres.

Cada construtor recebe um rótulo URI exclusivo.
URItoKind<A> mapeia rótulos para tipos concretos.
URIS é a união de todos os rótulos por meio de keyof.
A fusão de declarações permite que os módulos registrem novos contêineres.

Próximo: encapsular a consulta no padrão leve Kind.

Perguntas Frequentes

A aula “Definindo Construtores de Tipos” é grátis?

Sim — o texto completo de “Definindo Construtores de Tipos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 4 aulas no total.

O que vou aprender em “Definindo Construtores de Tipos”?

Codifique construtores de tipos como consultas em interfaces. Você pratica TypeScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar TypeScript Academy?

Nenhuma experiência prévia é necessária. TypeScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Definindo Construtores de Tipos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de TypeScript Academy?

Sim. Cada aula de TypeScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para TypeScript Academy