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

Una frase que he notado recientemente es el concepto de estilo "sin puntos" ...

Primero, estaba esta pregunta, y también esta .

Entonces, descubrí aquí que mencionan "Otro tema que puede valer la pena discutir es el desagrado 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 curado "automático"?

Para tener una idea de mi nivel, he estado aprendiendo Scheme por mí mismo y he escrito un intérprete de Scheme simple ... Entiendo lo que es el currying "implícito", pero no conozco ningún Haskell o ML.

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 la definición de una función no incluye información sobre sus argumentos, utilizando combinadores y composición de funciones [...] en lugar de variables.

Ejemplo de Haskell:

Convencional (especifica los argumentos explícitamente):

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

Sin puntos ( sumno tiene argumentos explícitos, es solo un pliegue que +comienza con 0):

 sum = foldr (+) 0

O incluso más simple: en lugar de g(x) = f(x), podría simplemente escribir g = f.

Entonces sí: está estrechamente relacionado con el curry (u operaciones como la composición de funciones).

El estilo sin puntos significa que los argumentos de la función que se define 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 en una que calcule x*x+1, puede definirla como "punto completo" así:

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

La alternativa libre de puntos sería no hablar del argumento x:

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

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

El estilo sin puntos significa que el código no menciona explícitamente sus argumentos, aunque existen y se están utilizando.

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 escribir explícitamente el argumento a menos que usted también lo desee.

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.