JavaScript Academy · Aula

Estilo point-free

Componha funções sem nomear argumentos.

Estilo point-free é uma aula grátis de JavaScript 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 JavaScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de JavaScript Academy inclui 4 aulas no total.

O que é o estilo sem argumentos

O estilo sem argumentos (ou tácito) define funções combinando outras funções, sem mencionar seus argumentos. Os argumentos são os pontos implícitos que são passados adiante.

function double(n) { return n * 2; }
const nums = [1, 2, 3];
// pointed: argument named explicitly
console.log(nums.map((n) => double(n))); // [2, 4, 6]
// point-free: no named argument
console.log(nums.map(double));            // [2, 4, 6]

Passando funções diretamente

Quando uma função de retorno simplesmente encaminha seu argumento para outra função, é possível passar essa função pelo nome em vez de envolvê-la.

const len = (s) => s.length;
const words = ["a", "bb", "ccc"];
console.log(words.map((w) => w.length)); // pointed: [1, 2, 3]
console.log(words.map(len));             // point-free: [1, 2, 3]

Composição de funções

O código sem argumentos depende da composição: criar uma nova função passando a saída de uma para a próxima.

const compose = (f, g) => (x) => f(g(x));
const inc = (n) => n + 1;
const double = (n) => n * 2;
const incThenDouble = compose(double, inc);
console.log(incThenDouble(3)); // (3+1)*2 = 8

Um auxiliar pipe

pipe lê da esquerda para a direita, o que muitas pessoas consideram mais claro do que compose. Ele aplica as funções na ordem.

const pipe = (...fns) => (x) => fns.reduce((acc, f) => f(acc), x);
const inc = (n) => n + 1;
const double = (n) => n * 2;
const f = pipe(inc, double);
console.log(f(3)); // 8

Criando fluxos de processamento

Com pipe, é possível expressar uma transformação de várias etapas como uma função nomeada sem jamais nomear os dados.

const pipe = (...fns) => (x) => fns.reduce((a, f) => f(a), x);
const trim = (s) => s.trim();
const lower = (s) => s.toLowerCase();
const clean = pipe(trim, lower);
console.log(clean("  HELLO  ")); // "hello"

A aplicação parcial encadeada permite o estilo sem argumentos

A aplicação parcial encadeada transforma uma função com vários argumentos em uma cadeia de funções com um único argumento. Isso produz funções unárias prontas para composição.

const multiply = (a) => (b) => a * b;
const triple = multiply(3);
console.log([1, 2, 3].map(triple)); // [3, 6, 9]

Aplicação parcial

Fixar alguns argumentos de antemão produz uma função especializada que pode ser passada diretamente, outro caminho para o código sem argumentos.

const add = (a, b) => a + b;
const add10 = add.bind(null, 10);
console.log([1, 2, 3].map(add10)); // [11, 12, 13]

Compondo predicados

É possível construir auxiliares booleanos uns a partir dos outros para obter filtros limpos e sem argumentos, sem o excesso de sintaxe de seta embutida.

const isEven = (n) => n % 2 === 0;
const negate = (fn) => (x) => !fn(x);
const isOdd = negate(isEven);
console.log([1, 2, 3, 4].filter(isOdd)); // [1, 3]

Compromissos de legibilidade

O estilo sem argumentos pode ser elegante, mas, levado longe demais, fica enigmático. Use-o quando esclarecer a intenção (map(double)) e mantenha os argumentos explícitos quando nomeá-los ajudar na compreensão.

const names = ["ada", "bob"];
console.log(names.map((n) => n.toUpperCase())); // ["ADA","BOB"]

Armadilha das referências a métodos

Passar um método pelo nome pode fazer você perder seu this. Envolva-o ou use bind nele quando a função depender do contexto de um objeto.

const calc = {
  factor: 2,
  scale(n) { return n * this.factor; }
};
console.log([1, 2].map(calc.scale.bind(calc))); // [2, 4]

Compondo transformações reais

Reunindo tudo: pequenas funções nomeadas, combinadas em um fluxo de processamento, proporcionam um fluxo de dados declarativo, fácil de testar e sem argumentos.

const pipe = (...fns) => (x) => fns.reduce((a, f) => f(a), x);
const toNums = (arr) => arr.map(Number);
const onlyPos = (arr) => arr.filter((n) => n > 0);
const sum = (arr) => arr.reduce((a, n) => a + n, 0);
const process = pipe(toNums, onlyPos, sum);
console.log(process(["3", "-1", "4"])); // 7

Verificação rápida

Estilo sem argumentos.

Recapitulação

O estilo sem argumentos cria funções compondo outras sem nomear os argumentos. Passe funções por referência (map(double)), componha com compose/pipe e use aplicação parcial encadeada ou aplicação parcial para criar funções unárias. Fique atento à perda de this em referências a métodos e mantenha os argumentos explícitos quando isso tornar a leitura mais clara.

Perguntas Frequentes

A aula “Estilo point-free” é grátis?

Sim — o texto completo de “Estilo point-free” é 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 JavaScript Academy, atualize para CoddyKit PRO. O curso de JavaScript Academy inclui 4 aulas no total.

O que vou aprender em “Estilo point-free”?

Componha funções sem nomear argumentos. Você pratica JavaScript 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 JavaScript Academy?

Nenhuma experiência prévia é necessária. JavaScript 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 “Estilo point-free”?

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 JavaScript Academy?

Sim. Cada aula de JavaScript 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 JavaScript Academy