TypeScript Academy · Aula

Composição de Funções com Tipos

Componha funções preservando a segurança de tipos.

Composição de Funções com Tipos é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 3 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 é composição?

A composição de funções combina funções pequenas em uma função maior. compose(f, g) produz uma função que aplica primeiro g e depois passa o resultado para f.

A definição principal

Matematicamente, compose(f, g)(x) = f(g(x)). As funções são executadas da direita para a esquerda: a mais à direita é executada primeiro.

const compose = (f: (n: number) => number, g: (n: number) => number) =>
  (x: number) => f(g(x));
const inc = (n: number) => n + 1;
const dbl = (n: number) => n * 2;
console.log(compose(inc, dbl)(5)); // 11 (5*2 then +1)

Ordem da direita para a esquerda

A ordem importa. compose(inc, dbl) dobra primeiro e depois incrementa, enquanto compose(dbl, inc) incrementa primeiro. Leia a composição de dentro para fora.

console.log(compose(dbl, inc)(5)); // 12 (5+1 then *2)

Tipando a composição com genéricos

Os genéricos permitem que os tipos de entrada e saída sejam diferentes. g mapeia A para B, f mapeia B para C, e o resultado mapeia A para C.

function compose<A, B, C>(f: (b: B) => C, g: (a: A) => B): (a: A) => C {
  return a => f(g(a));
}

Alterando os tipos ao longo do caminho

Como os genéricos formam a cadeia A -> B -> C, a composição pode transformar um valor entre vários formatos, como de texto para número e depois para texto.

const length = (s: string) => s.length;
const toStr = (n: number) => "len=" + n;
const describe = compose(toStr, length);
console.log(describe("hello")); // len=5

O limite entre os tipos deve corresponder

A saída de g deve corresponder à entrada de f. Se houver uma divergência, o compilador rejeita a composição e detecta erros de ligação antecipadamente.

// compose(length, toStr) would error:
// toStr returns string, length expects string -> ok here,
// but mismatched pairs are flagged by the compiler.

Compondo três funções

Você pode aninhar composições ou escrever uma versão com três argumentos. A regra da direita para a esquerda continua valendo em todos os casos.

const compose3 = <A, B, C, D>(
  f: (c: C) => D, g: (b: B) => C, h: (a: A) => B
) => (a: A): D => f(g(h(a)));
const inc = (n: number) => n + 1;
const dbl = (n: number) => n * 2;
const neg = (n: number) => -n;
console.log(compose3(neg, dbl, inc)(3)); // -8

A composição cria encadeamentos

Ao compor funções pequenas e puras, você monta transformações complexas de forma declarativa. Cada parte continua testável de maneira isolada.

const trim = (s: string) => s.trim();
const upper = (s: string) => s.toUpperCase();
const clean = compose(upper, trim);
console.log(clean("  hi ")); // HI

Por que funções puras são melhores para composição

A composição pressupõe que cada função depende apenas da sua entrada. As funções puras garantem isso; portanto, compô-las produz outra função pura e previsível.

compose versus encadeamento

compose executa da direita para a esquerda e segue a notação matemática. Muitas pessoas preferem a leitura da esquerda para a direita, que é oferecida por pipe e será abordada a seguir.

Mantenha as partes pequenas

A composição se destaca quando cada função faz uma única coisa pequena. Etapas pequenas, nomeadas e puras tornam o encadeamento composto autoexplicativo e fácil de reorganizar.

Verificação rápida

Verificação rápida sobre esta lição.

Recapitulação

compose(f, g)(x) = f(g(x)), executado da direita para a esquerda. As cadeias de tipos genéricos A -> B -> C exigem que a saída de g corresponda à entrada de f, permitindo que o compilador verifique o encadeamento de funções pequenas e puras.

Perguntas Frequentes

A aula “Composição de Funções com Tipos” é grátis?

Sim — o texto completo de “Composição de Funções com 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 “Composição de Funções com Tipos”?

Componha funções preservando a segurança de tipos. 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 3 de 4.

Quanto tempo leva a aula “Composição de Funções com 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