O que é uma DSL no Nível de Tipos
Utilize tipos para restringir uma API fluente a programas válidos.
O que é uma DSL no Nível de Tipos é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 1 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.
O que é uma DSL em nível de tipos
Uma DSL em nível de tipos (linguagem específica de domínio) usa tipos TypeScript para restringir uma API, de modo que apenas programas válidos sejam compilados. Os tipos funcionam como uma gramática: combinações inválidas são rejeitadas antes mesmo de o código ser executado.
DSLs incorporadas
Uma DSL incorporada vive dentro da linguagem hospedeira (neste caso, TypeScript), em vez de ser um analisador separado. Você escreve TS comum, mas o sistema de tipos impõe as regras da DSL.
Um exemplo conhecido
Você já usou DSLs em nível de tipos: um construtor de consultas que permite apenas nomes de colunas válidos ou um roteador que infere parâmetros de um caminho. Os tipos codificam o que a API permite.
Restringindo uma API fluente
A ideia central: cada método retorna um tipo que limita quais métodos você pode chamar em seguida. Chamar elementos na ordem errada impede a compilação.
interface Empty { from(t: string): HasFrom; }
interface HasFrom { where(c: string): HasFrom; select(): string; }
declare const q: Empty;
q.from("users").select(); // ok
q.select(); // Error: select not on EmptyMáquinas de estados em tipos
Esse padrão é uma máquina de estados em nível de tipos: cada interface é um estado, cada método é uma transição para outro estado. O compilador percorre a máquina à medida que você encadeia chamadas.
Por que não apenas verificações em tempo de execução
As verificações em tempo de execução falham tarde, em produção, com usuários presentes. Uma DSL em nível de tipos falha cedo, no editor, com um sublinhado vermelho, antes de o código ser lançado. As mesmas regras, com um retorno muito mais barato.
Parâmetros de tipo fantasma
As DSLs frequentemente transportam informações em parâmetros de tipo fantasma: genéricos que existem apenas em tempo de compilação para acompanhar o estado acumulado (colunas selecionadas, variáveis vinculadas), sem custo em tempo de execução.
interface Query<Selected extends string> {
select<C extends string>(c: C): Query<Selected | C>;
}Tipos literais como símbolos
Tipos literais de cadeias de caracteres funcionam como símbolos da DSL. Combinados com literais de modelo e uniões, eles permitem que o sistema de tipos raciocine sobre o conteúdo textual da sua DSL.
type Direction = "asc" | "desc";
declare function orderBy(col: string, dir: Direction): void;
orderBy("age", "asc"); // ok
orderBy("age", "up"); // Error: not a DirectionOs blocos de construção
As DSLs em nível de tipos combinam: genéricos para o estado, tipos condicionais para ramificações, literais de modelo para analisar cadeias de caracteres e tipos mapeados para transformar estruturas. As lições posteriores usam cada um deles.
Compromissos
As DSLs em nível de tipos oferecem garantias fortes, mas podem produzir erros enigmáticos e compilações mais lentas se forem usadas em excesso. Boas DSLs equilibram segurança e mensagens de erro legíveis (uma lição posterior aborda isso).
Por que isso importa
Codificar regras do domínio nos tipos faz o compilador se tornar um especialista no domínio: ele rejeita automaticamente absurdos. É assim que construtores de consultas, bibliotecas de formulários e sistemas de efeitos oferecem garantias tão fortes.
Verificação rápida
Teste sua compreensão das DSLs em nível de tipos.
Recapitulação
Uma DSL em nível de tipos usa tipos TypeScript como uma gramática, para que apenas programas válidos sejam compilados. As APIs fluentes modelam máquinas de estados nas quais cada método retorna um tipo que restringe o estado, usando genéricos fantasmas, símbolos de tipos literais, tipos condicionais, tipos de literais de modelo e tipos mapeados como blocos de construção, proporcionando retorno antecipado no editor.
Perguntas Frequentes
A aula “O que é uma DSL no Nível de Tipos” é grátis?
Sim — o texto completo de “O que é uma DSL no Nível 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 “O que é uma DSL no Nível de Tipos”?
Utilize tipos para restringir uma API fluente a programas válidos. 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 1 de 4.
Quanto tempo leva a aula “O que é uma DSL no Nível 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
- O que é uma DSL no Nível de Tipos
- Projetando uma DSL Fluente de Consultas
- Validação de Entrada em Tempo de Compilação
- Mensagens de Erro em DSLs no Nível de Tipos