Neste artigo
- O que torna uma função pura?
- Por que teste fica trivial com pureza
- Imutabilidade na prática do dia a dia
- Concorrência: o argumento decisivo
- Onde a pureza termina: bordas e efeitos
- Imutabilidade sem custo de performance desnecessário
- Como identificar e corrigir o impuro no código existente
- Função pura não pode chamar API?
- Imutabilidade deixa o código mais lento?
- Como nomear funções puras?
- Bibliotecas de front-end usam esses conceitos?
- Como começar a aplicar em código legado mutável?
Função pura é a que devolve sempre o mesmo resultado para a mesma entrada e não altera nada fora de si; imutabilidade é a prática de criar dados novos em vez de modificar os existentes. As duas ideias importam porque eliminam a maior fonte de bug difícil: estado que muda em um lugar e surpreende em outro.
Funções puras e dados imutáveis tornam o comportamento previsível, o teste trivial e a concorrência segura, e por isso aparecem de bibliotecas de interface a sistemas distribuídos. O primeiro passo é parar de alterar parâmetros e objetos recebidos. Em JavaScript tipado, o guia de TypeScript do zero mostra como a assinatura explícita reduz os desvios que a mutação esconde.
O que torna uma função pura?
Duas condições, e apenas duas: a saída depende só dos argumentos, e a função não produz efeito colateral. Uma soma de dois parâmetros é pura, porque o resultado depende deles e de mais nada. A mesma função que grava log, consulta variável global ou atualiza banco deixa de ser pura. O teste rápido é perguntar se mover a chamada de lugar pode mudar o resultado.
// impura: altera o objeto recebido
function aplicarDesconto(pedido) {
pedido.total = pedido.total * 0.9;
return pedido;
}
// pura: cria um novo valor
const comDesconto = pedido => ({ ...pedido, total: pedido.total * 0.9 });
As duas versões entregam o total com desconto, e apenas a segunda deixa o pedido original intacto para o resto do fluxo.
Por que teste fica trivial com pureza
Testar função pura é listar entradas e saídas esperadas: sem simulacro de relógio, sem banco em memória, sem ordem de execução. A tabela de casos cobre o comportamento e documenta o contrato. A mutação escondida é o que gera teste frágil, porque o resultado depende de estado alterado por outros testes. E ver o que acontece quando o teste é gerado por IA confirma o ponto: a qualidade da sugestão acompanha a pureza do código analisado.
Imutabilidade na prática do dia a dia
Imutabilidade não exige linguagem funcional: em JavaScript, o spread cria objetos novos; em Python, tuplas cobrem casos comuns; em Java, records resolvem. A regra é simples: funções recebem dados e devolvem dados novos, e a alteração fica nas bordas onde o estado vive, como banco e interface.
💡 Dica: trate todo parâmetro de função como somente leitura, mesmo em linguagem que não impõe. Copiar antes de alterar custa pouco na maioria dos trechos, e o hábito elimina a classe de bug em que uma função quebra outra sem aviso.
Concorrência: o argumento decisivo
Bug de concorrência nasce de estado compartilhado mutável, e imutabilidade elimina a categoria: dado que ninguém altera não precisa de trava para ser lido por múltiplas threads. É o desenho de sistemas com paralelismo real, e a razão pela qual linguagens funcionais dominam domínios em que corrida de dados custa caro.
Onde a pureza termina: bordas e efeitos
Sistema real precisa de efeito: gravar, enviar, renderizar. O desenho saudável concentra os efeitos na borda, e mantém o núcleo puro: a função que calcula o total não grava nada, e quem chama decide o que fazer com o resultado. Essa separação deixa a regra reutilizável em HTTP, fila e job, e o guia completo da linguagem ajuda a ver onde a borda começa.
Imutabilidade sem custo de performance desnecessário
Copiar o mundo a cada alteração é o equívoco que mata a imutabilidade por performance: spread em estrutura grande dentro de laço quente cria custo de alocação que o projeto não paga. A forma certa é copiar o caminho do dado que mudou e reutilizar o resto; bibliotecas e padrões atuais fazem isso de forma transparente, e o mesmo raciocínio vale para imutabilidade em coleções pequenas, onde a cópia é barata e a clareza compensa.
A disciplina que de fato muda o dia a dia é a da entrada de dado: cópia na fronteira, leitura compartilhada no núcleo, reatribuição explícita. Quando a tipagem ajuda a escrever isso sem defesa manual, a clareza aumenta; o guia de TypeScript do zero mostra como tipar estruturas que se comportam como imutáveis sem custo de cópia.
Como identificar e corrigir o impuro no código existente
O sinal mais confiável de impureza não está no nome da função, está na assinatura: função que não recebe argumento e devolve valor diferente a cada chamada, função que altera objeto recebido ou função que depende de variável de fora do escopo. Listar essas funções do projeto já revela onde vivem os bugs mais difíceis de reproduzir, porque são exatamente os pontos em que o resultado depende de contexto invisível.
A correção segue uma sequência que quase sempre funciona. Primeiro, isole o cálculo: tudo que a função decide deve sair dos parâmetros e do retorno. Depois, mova a alteração de estado para quem chama, para que a função apenas produza o dado novo. Por fim, empurre o efeito, como gravação e envio, para a borda do sistema, onde ele fica fácil de trocar e de simular em teste.
O ganho é acumulativo: cada função purificada se torna testável com uma tabela de casos, reutilizável em outro fluxo e legível sem saltar entre arquivos. Comece pelas funções que já causaram bug, porque o histórico de incidentes aponta melhor que qualquer ferramenta onde a pureza falta primeiro.
Perguntas frequentes
Função pura não pode chamar API?
Não enquanto função pura. O padrão comum separa as partes: uma função pura monta a requisição e interpreta a resposta, e a borda executa a chamada e entrega os dados.
Imutabilidade deixa o código mais lento?
Copiar tem custo, e estruturas persistentes minimizam o impacto. Na maioria dos sistemas, o gargalo está em rede e banco, e o ganho de previsibilidade compensa a diferença.
Como nomear funções puras?
Prefira nomes que descrevem a transformação e o retorno, como totalComDesconto. Verbos com substância comunicam que a função devolve valor novo, e não altera o que recebeu.
Bibliotecas de front-end usam esses conceitos?
Usam, e de forma central: componente é função pura das propriedades, estado é imutável, e a renderização reexecuta a partir de entradas novas.
Como começar a aplicar em código legado mutável?
Escolha um módulo com muitos bugs e converta as funções de cálculo em puras uma por vez, mantendo as bordas como estão. Os testes da região ficam mais simples, e o ganho vira argumento para seguir.