¿Qué es un estilo sin puntos en la programación funcional?

Question

Una frase que me he dado cuenta recientemente es el concepto de estilo "libre punto" ...

En primer lugar, hubo this cuestión, y also this one.

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, he estado enseñándome 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.

Answer 1

basta con ver el Wikipedia article para obtener su definición:

programación tácita (punto libre de la programación) es un paradigma de programación en el que una definición de función no incluye información relativa a sus argumentos, usando combinadores y composición de funciones [...] en lugar de variables

Haskell ejemplo:

convencional (que especifica los argumentos explícitamente):

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

-Point libre (sum todavía no tiene ninguna argumentos explícitos - es sólo un pliegue con + comenzando con 0):

sum = foldr (+) 0 

O incluso más simple: en lugar de g(x) = f(x) , puedes escribir g = f.

Así que sí: Está estrechamente relacionado con el currying (u operaciones como la composición de funciones).

Answer 2

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 quieres combinar estas dos funciones a la que calcula x*x+1, se puede definir que "apuntar completa" de esta manera:

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

la alternativa libre de punto sería no hablar sobre el argumento x:

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

Answer 3

El estilo sin puntos significa que el código no menciona explícitamente sus argumentos, aunque existan y estén en uso.

Esto funciona en Haskell debido a la forma en que funcionan las funciones.

Por ejemplo:

myTake = take 

devuelve una función que toma un argumento, por lo tanto, no hay razón para el tipo explícita el argumento a menos que quieran también. muestra

Answer 4

una búsqueda 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' 

Reference

Answer 5

Aquí es un ejemplo a máquina de escribir 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; 
    } 
    } 
} 

Se puede ver el estilo libre de puntos es más "fluidez" y más fácil de leer