TypeScript Academy · Aula

Functoras e Mapeadoras Genéricas

Escreva funções map genéricas para qualquer contêiner.

Aula 4 de 413 etapas

Functoras e Mapeadoras Genéricas é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 4 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.

Um Functor Genérico

Agora usamos a codificação para seu objetivo: um map genérico que funciona com qualquer contêiner registrado. A interface Functor, parametrizada por uma URI, declara um método.

interface Functor<F extends URIS> {
  readonly URI: F;
  map<A, B>(fa: Kind<F, A>, f: (a: A) => B): Kind<F, B>;
}

A Instância de Vetor

Uma instância implementa map para uma URI. A instância de vetor realiza o mapeamento usando o método integrado de vetores. Seu Kind<"Array", A> é resolvido para A[].

const arrayFunctor: Functor<"Array"> = {
  URI: "Array",
  map: (fa, f) => fa.map(f)
};

Usando a Instância de Vetor

Chamar map na instância de vetor transforma cada elemento e preserva o tipo de contêiner vetor.

const doubled = arrayFunctor.map([1, 2, 3], n => n * 2);
// doubled: number[] -> [2, 4, 6]

O Tipo Opção

Defina uma opção como um valor ou null e registre-a. Seu map aplica a função somente quando há um valor; caso contrário, propaga null.

interface URItoKind<A> { Option: A | null }
type Option<A> = A | null;

A Instância de Opção

A instância de opção preserva o contêiner de opção: uma função é aplicada ao valor, e um null continua sendo null.

const optionFunctor: Functor<"Option"> = {
  URI: "Option",
  map: (fa, f) => (fa === null ? null : f(fa))
};

Usando a Instância de Opção

Agora o mesmo formato de map funciona em um contêiner completamente diferente. Os valores presentes são transformados; os valores ausentes permanecem inalterados.

const a = optionFunctor.map(5, n => n + 1);    // 6
const b = optionFunctor.map(null, n => n + 1); // null

Uma Abstração, Muitos Contêineres

Esse é o benefício. arrayFunctor e optionFunctor compartilham a mesma interface Functor. O código escrito para Functor<F> funciona para ambos sem alterações.

function bumpAll<F extends URIS>(
  F: Functor<F>,
  fa: Kind<F, number>
): Kind<F, number> {
  return F.map(fa, n => n + 1);
}

Chamando a Função Genérica

bumpAll não sabe nem se importa com qual contêiner recebe. Passe a instância e os dados; o resultado preservará o tipo do contêiner.

const arr = bumpAll(arrayFunctor, [1, 2]); // number[] -> [2, 3]
const opt = bumpAll(optionFunctor, 9);     // number | null -> 10

Leis dos Functors

Um functor correto obedece a duas leis: mapear a função identidade não altera nada, e mapear duas funções em sequência equivale a mapear sua composição. As instâncias de vetor e opção acima satisfazem ambas.

// map(fa, x => x) === fa
// map(map(fa, f), g) === map(fa, x => g(f(x)))

Adicionando Mais Instâncias

Como a abstração é aberta, novos contêineres podem ser conectados registrando uma URI e fornecendo uma instância. Uma árvore, um resultado, uma tarefa: cada um pode ser mapeado pelo mesmo código genérico.

// Register URI, implement Functor<"Tree">,
// and bumpAll works on trees too - no edits to bumpAll

Por Que Isso Importa

Os functors genéricos são a porta de entrada para as abstrações funcionais no TypeScript: aplicativos, mônadas e travessias. Cada uma é uma interface sobre Kind<F, A>, com instâncias por contêiner. Agora você entende o mecanismo que torna o fp-ts e o Effect possíveis.

interface Monad<F extends URIS> extends Functor<F> {
  of<A>(a: A): Kind<F, A>;
  chain<A, B>(fa: Kind<F, A>, f: (a: A) => Kind<F, B>): Kind<F, B>;
}

Verificação Rápida

Teste sua compreensão dos functors genéricos.

Responda na aula interativa

Recapitulação

Você escreveu um map genérico para contêineres.

Functor<F> declara map sobre Kind<F, A>.
As instâncias de vetor e opção o implementam para suas URIS.
Código genérico como bumpAll funciona para qualquer contêiner registrado.
As leis dos functors mantêm as instâncias bem-comportadas; abstrações mais avançadas se baseiam nisso.

Próximo, Curso 24: criando analisadores com segurança de tipos.

Grátis para começar

Aprenda TypeScript com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 101
Aulas: 352

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Functoras e Mapeadoras Genéricas” é grátis?

Sim — o texto completo de “Functoras e Mapeadoras Genéricas” é 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 “Functoras e Mapeadoras Genéricas”?

Escreva funções map genéricas para qualquer contêiner. 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 4 de 4.

Quanto tempo leva a aula “Functoras e Mapeadoras Genéricas”?

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