functional-programming - paradigmas - programacion imperativa
¿Qué es el estilo sin puntos en la programación funcional? (5)
Una frase que he notado recientemente es el concepto de estilo "sin puntos" ...
Primero, estaba this pregunta, y también esta .
Luego, descubrí here que mencionan "Otro tema que puede valer la pena discutir es la antipatía de los autores hacia el estilo sin puntos".
¿Qué es el estilo "sin puntos"? ¿Alguien puede dar una explicación concisa? ¿Tiene algo que ver con el currying "automático"?
Para tener una idea de mi nivel, me he estado enseñando Scheme, y he escrito un simple intérprete de Scheme ... Entiendo qué es el currículum "implícito", pero no conozco ningún Haskell o ML.
Aquí hay un ejemplo en TypeScript sin ninguna otra 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;
}
}
}
Puede ver que el estilo sin puntos es más "fluido" y más fácil de leer.
El estilo sin puntos significa que el código no menciona explícitamente sus argumentos, aunque existen y están siendo utilizados.
Esto funciona en Haskell por la forma en que funcionan las funciones.
Por ejemplo:
myTake = take
devuelve una función que toma un argumento, por lo tanto, no hay ninguna razón para escribir explícitamente el argumento a menos que usted también lo desee.
Estilo sin puntos significa que los argumentos de la función que se está definiendo no se mencionan explícitamente, que la función se define mediante la composición de funciones.
Si tiene dos funciones, como
square :: a -> a
square x = x*x
inc :: a -> a
inc x = x+1
y si desea combinar estas dos funciones con una que calcule x*x+1 , puede definirla como "punto lleno" de la siguiente manera:
f :: a -> a
f x = inc (square x)
La alternativa sin puntos sería no hablar sobre el argumento x :
f :: a -> a
f = inc . square
Solo mira el artículo de Wikipedia para obtener tu definición:
La programación tácita (programación sin puntos) es un paradigma de programación en el que una definición de función no incluye información sobre sus argumentos, utilizando combinators y composición de función [...] en lugar de variables.
Ejemplo de Haskell:
Convencional (usted especifica los argumentos explícitamente):
sum (x:xs) = x + (sum xs)
sum [] = 0
Sin puntos ( sum no tiene ningún argumento explícito, es solo un doble con + comenzando con 0):
sum = foldr (+) 0
O incluso más simple: en lugar de g(x) = f(x) , podrías simplemente escribir g = f .
Entonces sí: está estrechamente relacionado con el currying (o operaciones como la composición de funciones).
Una muestra 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''