O que é o estilo point free Em Programação Funcional?
uma frase que eu notei recentemente é o conceito de "ponto livre" estilo...
Primeiro, havia esta pergunta, e também esta .
Então, eu descobri aqui eles mencionam " outro tópico que pode valer a pena discutir é a antipatia dos autores do estilo livre de pontos."
O que é o estilo" sem pontos"? Alguém pode dar uma explicação concisa? Tem alguma coisa a ver com o encarceramento "automático"? Para ter uma ideia do meu nível - Tenho andado a ensinar-me um esquema, e tenho escrito um simples intérprete de esquemas... Eu entendo o que é" enrolar implícito", mas não conheço nenhum Haskell ou ML.5 answers
Basta olhar para o artigo da Wikipédia para obter a sua definição:
Programação tácita (programação sem pontos) é um paradigma de programação em que uma definição de função não inclui informações sobre seus argumentos, usando combinadores e composição de funções [...] em vez de variáveis.
Haskell exemplo:
Convencional (você especifica os argumentos explicitamente):
sum (x:xs) = x + (sum xs)
sum [] = 0
Sem pontos (sum não tem nenhum explícito argumentos - é apenas uma dobra com + começando com 0):
sum = foldr (+) 0
Ou ainda mais simples: em vez de g(x) = f(x), podias escrever g = f.
O estilo livre de Pontos significa que os argumentos da função a ser definida não são explicitamente mencionados, que a função é definida através da composição da função.
Se tem duas funções, como
square :: a -> a
square x = x*x
inc :: a -> a
inc x = x+1
E se quiser combinar estas duas funções com uma que calcula x*x+1, pode defini-la "point-full" como esta:
f :: a -> a
f x = inc (square x)
x:
f :: a -> a
f = inc . square
Uma amostra de JavaScript:
//not pointfree cause we receive args
var initials = function(name) {
return name.split(' ').map(compose(toUpperCase, head)).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 os seus argumentos, mesmo que existam e estejam a ser usados.
Isto funciona em Haskell por causa da forma como as funções funcionam.
Por exemplo:
myTake = take
Retorna uma função que leva um argumento, portanto, não há razão para especificar o argumento a menos que você apenas queira também.
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 livre de pontos é mais "fluente" e mais fácil de ler.