Quel est le style « point libre » (en programmation fonctionnelle)?

Question

Une phrase que j'ai remarqué récemment est le concept de style "point libre" ...

Tout d'abord, il y avait cette question et < a href = "https://stackoverflow.com/questions/907306/confusion-about-currying-and-point-free-style-in-haskell"> aussi celui-ci .

Alors, j'ai découvert ils mentionnent « Un autre sujet qui peut être intéressant de discuter est l'aversion des auteurs du point de style libre ».

Quel est le style "point libre"? Quelqu'un peut-il donner une explication concise? At-il quelque chose à voir avec curryfication « automatique »?

Pour avoir une idée de mon niveau - je me suis enseigné Scheme, et ai écrit d'un simple interprète de schéma ... Je comprends ce que « implicite » curryfication est, mais je ne sais pas Haskell ou ML <. / p>

Answer 1

Il suffit de regarder à la Wikipedia article pour obtenir votre définition:

  

Programmation Tacite (programmation point gratuit) est un paradigme de programmation dans lequel une définition de fonction ne comprend pas d'informations en ce qui concerne ses arguments, en utilisant combinateurs et la composition de la fonction [...] au lieu des variables.

Exemple Haskell:

classique (vous spécifiez les arguments explicitement):

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

sans point (sum n'a pas d'argument explicite - c'est juste un pli avec + en commençant par 0):

 sum = foldr (+) 0

Ou encore plus simple. Au lieu de g(x) = f(x), vous pouvez simplement écrire g = f

Alors oui: Il est étroitement lié à taitement (ou des opérations telles que la composition de fonction)

.

Answer 2

signifie style de point sans que les arguments de la fonction étant définie ne sont pas mentionnés explicitement, que la fonction est définie par la composition de la fonction.

Si vous avez deux fonctions, comme

square :: a -> a
square x = x*x

inc :: a -> a
inc x = x+1

et si vous voulez combiner ces deux fonctions qui calcule x*x+1, vous pouvez définir « point complet » comme ceci:

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

L'alternative point sans serait de ne pas parler de l'argument x:

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

Answer 3

Un échantillon 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'

Référence

Answer 4

Point de style libre signifie que le code ne mentionne pas explicitement ses arguments, même si elles existent et sont utilisés.

Cela fonctionne dans Haskell en raison du travail des fonctions à sens unique.

Par exemple:

myTake = take

retourne une fonction qui prend un argument, donc il n'y a aucune raison de type explicite l'argument sauf si vous voulez tout simplement trop.

Answer 5

Voici un exemple dactylographiée sans aucune autre bibliothèque:

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;
    }
  }
}

Vous pouvez voir le style sans point est plus « fluent » et plus facile à lire.