O que é o estilo “sem pontos” (em Programação Funcional)?

Uma frase que notei recentemente é o conceito de estilo "ponto livre" ...

Primeiro, havia essa pergunta, e também essa .

Então, descobri aqui que eles mencionam "Outro tópico que pode valer a pena discutir é a aversão dos autores ao estilo livre de pontos".

O que é o estilo "sem pontos"? Alguém pode dar uma explicação concisa? Tem algo a ver com curry "automático"?

Para ter uma ideia do meu nível - tenho ensinado Scheme a mim mesmo e escrevi um interpretador Scheme simples ... Eu entendo o que é currying "implícito", mas não conheço nenhum Haskell ou ML.

Basta olhar para o artigo da Wikipedia para obter sua definição:

A programação tácita (programação livre de pontos) é um paradigma de programação em que a definição de uma função não inclui informações sobre seus argumentos, utilizando combinadores e composição [...] de funções ao invés de variáveis.

Exemplo de Haskell:

Convencional (você especifica os argumentos explicitamente):

sum (x:xs) = x + (sum xs)
sum [] = 0

Livre de pontos ( sumnão tem argumentos explícitos - é apenas uma dobra +começando com 0):

 sum = foldr (+) 0

Ou ainda mais simples: em vez de g(x) = f(x), você pode apenas escrever g = f.

Então, sim: está intimamente relacionado ao currying (ou operações como composição de funções).

O estilo sem pontos significa que os argumentos da função que está sendo definida não são mencionados explicitamente, que a função é definida por meio da composição da função.

Se você tem duas funções, como

square :: a -> a
square x = x*x

inc :: a -> a
inc x = x+1

e se você quiser combinar essas duas funções com uma que calcule x*x+1, você pode defini-la como "ponto cheio" assim:

f :: a -> a
f x = inc (square x)

A alternativa livre de pontos seria não falar sobre o argumento x:

f :: a -> a
f = inc . square

Um exemplo de JavaScript:

//not pointfree cause we receive args
var initials = function(name) {
  return name.split(' ').map(compose(toUpperCase, head)).join('. ');
};

const compose = (...fns) => (...args) => fns.reduceRight((res, fn) => [fn.call(null, ...res)], args)[0];
const join = m => m.join();

//pointfree
var initials = compose(join('. '), map(compose(toUpperCase, head)), split(' '));

initials("hunter stockton thompson");
// 'H. S. T'

Referência

O estilo livre de pontos significa que o código não menciona explicitamente seus argumentos, mesmo que eles existam e estejam sendo usados.

Isso funciona em Haskell por causa da maneira como as funções funcionam.

Por exemplo:

myTake = take

retorna uma função que leva um argumento, portanto, não há razão para digitar explicitamente o argumento, a menos que você apenas queira.

Aqui está um exemplo em TypeScript sem qualquer outra biblioteca:

interface Transaction {
  amount: number;
}

class Test {
  public getPositiveNumbers(transactions: Transaction[]) {
    return transactions.filter(this.isPositive);

    //return transactions.filter((transaction: {amount: number} => transaction.amount > 0));
  }

  public getBigNumbers(transactions: Transaction[]) {
    // point-free
    return transactions.filter(this.moreThan(10));

    // not point-free
    // return transactions.filter((transaction: any) => transaction.amount > 10);
  }

  private isPositive(transaction: Transaction) {
    return transactions.amount > 0;
  }

  private moreThan(amount: number) {
    return (transaction: Transaction) => {
      return transactions.amount > amount;
    }
  }
}

Você pode ver que o estilo sem pontos é mais "fluente" e fácil de ler.