¿Qué es el estilo “sin puntos” (en programación funcional)?

Question

Una frase que he notado recientemente es el concepto de estilo "punto libre"...

Primero, hubo este pregunta, y también este.

Entonces descubrí aquí mencionan "Otro tema que puede valer la pena discutir es la aversión de los autores por el estilo libre de puntos".

¿Qué es el estilo "sin puntos"?¿Alguien puede dar una explicación concisa?¿Tiene algo que ver con el curry "automático"?

Para tener una idea de mi nivel, he estado aprendiendo Scheme por mi cuenta y he escrito un intérprete de Scheme simple...Entiendo lo que es el curry "implícito", pero no conozco Haskell ni ML.

Answer 1

Basta con mirar el artículo de Wikipedia para obtener su definición:

  

tácito de programación (programación libre de punto) 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 la función [...] en lugar de variables.

Haskell ejemplo:

Convencional (que especifique los argumentos explícitamente):

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

punto libre (sum no tiene ningún argumentos explícitos - es sólo un pliegue con + empezando por 0):

 sum = foldr (+) 0

O aún más simple:. En lugar de g(x) = f(x), usted podría escribir g = f

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

.

Answer 2

estilo libre de punto significa que no se mencionan explícitamente los argumentos de la función que se está definida, que la función se define a través de 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 no sería para hablar de la x argumento:

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

Answer 3

Una muestra 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'

referencia

Answer 4

estilo libre del punto significa que el código no explícitamente menciona sus argumentos, a pesar de que existen y están siendo utilizados.

Esto funciona en Haskell, debido a la forma en que las funciones de trabajo.

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 sólo quieren también.

Answer 5

Aquí es un ejemplo a máquina 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 el estilo libre de punto es más "fluida" y más fácil de leer.