Qual é o estilo “livre point” (em programação funcional)?

Question

Uma frase que eu notei recentemente é o conceito de "ponto de acesso gratuito" estilo ...

Primeiro, houve esta questão , e < a href = "https://stackoverflow.com/questions/907306/confusion-about-currying-and-point-free-style-in-haskell"> também esta .

Então, eu descobri href="http://lambda-the-ultimate.org/node/3331" aqui eles mencionam "Outro tema que pode valer a pena discutir é antipatia dos autores do estilo livre ponto ".

O que é estilo "livre ponto"? Alguém pode dar uma explicação concisa? Será que ela tem algo a ver com currying "automático"?

Para ter uma idéia do meu nível - Eu tenho me ensinando Scheme, e tem escrito uma simples intérprete Esquema ... Eu entendo o "implícito" currying é, mas eu não conheço nenhum Haskell ou ML <. / p>

Answer 1

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

programação tácito (programação livre de ponto) é um paradigma de programação em que a definição de função não inclui informações sobre os seus argumentos, usando combinadores e composição de função [...] em vez de variáveis.

Haskell exemplo:

Convencional (especificar os argumentos explicitamente):

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

Ponto-free (sum não tem nenhum argumentos explícitos - é apenas uma dobra com + começando com 0):

 sum = foldr (+) 0

Ou ainda mais simples:. Em vez de g(x) = f(x), você poderia g = f basta escrever

Então, sim:. É estreitamente relacionada com currying (ou operações como composição de função)

Answer 2

meios estilo de ponto-livres que os argumentos da função a ser definida, não estão explicitamente mencionado, que a função é definida através de composição de 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 para um que calcula x*x+1, você pode defini-lo "ponto-cheio" como esta:

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

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

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

Answer 3

amostra A 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

Answer 4

ponto meios de estilo livre que o código não menciona explicitamente seus argumentos, mesmo que eles existem e estão sendo usados.

Isso funciona em Haskell Devido à forma como as funções de trabalho.

Por exemplo:

myTake = take

retorna uma função que leva um argumento, portanto, não há razão para tipo explícito o argumento a menos que você só quer também.

Answer 5

Aqui está um exemplo à máquina, 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 o estilo livre de ponto é mais "fluente" e mais fácil de ler.