Was ist ein "punktfreier" Stil (in der funktionalen Programmierung)?

Ein Satz, den ich kürzlich bemerkt habe, ist das Konzept des "punktfreien" Stils ...

Zuerst gab es diese und auch diese Frage .

Dann entdeckte ich hier, dass sie erwähnen: "Ein weiteres Thema, das es wert sein könnte, diskutiert zu werden, ist die Abneigung der Autoren gegen punktfreien Stil."

Was ist "punktfreier" Stil? Kann jemand eine kurze Erklärung geben? Hat es etwas mit "automatischem" Currying zu tun?

Um eine Vorstellung von meinem Niveau zu bekommen - ich habe mir selbst Scheme beigebracht und einen einfachen Scheme-Interpreter geschrieben ... Ich verstehe, was "implizites" Currying ist, aber ich kenne kein Haskell oder ML.

Schauen Sie sich einfach den Wikipedia-Artikel an, um Ihre Definition zu erhalten:

Die stillschweigende Programmierung (punktfreie Programmierung) ist ein Programmierparadigma, bei dem eine Funktionsdefinition keine Informationen zu ihren Argumenten enthält, wobei Kombinatoren und die Funktionszusammensetzung [...] anstelle von Variablen verwendet werden.

Haskell Beispiel:

Konventionell (Sie geben die Argumente explizit an):

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

Punktfrei ( sumhat keine expliziten Argumente - es ist nur eine Falte +mit 0):

 sum = foldr (+) 0

Oder noch einfacher: Stattdessen g(x) = f(x)könnte man einfach schreiben g = f.

Also ja: Es hängt eng mit dem Curry (oder Operationen wie der Funktionszusammensetzung) zusammen.

Punktfreier Stil bedeutet, dass die Argumente der zu definierenden Funktion nicht explizit erwähnt werden, sondern dass die Funktion durch Funktionszusammensetzung definiert wird.

Wenn Sie zwei Funktionen haben, wie

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

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

und wenn Sie diese beiden Funktionen zu einer berechneten kombinieren möchten x*x+1, können Sie sie wie folgt "punktvoll" definieren:

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

Die sinnlose Alternative wäre, nicht über das Argument zu sprechen x:

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

Ein JavaScript-Beispiel:

//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'

Referenz

Punktfreier Stil bedeutet, dass der Code seine Argumente nicht explizit erwähnt, obwohl sie vorhanden sind und verwendet werden.

Dies funktioniert in Haskell aufgrund der Funktionsweise von Funktionen.

Zum Beispiel:

myTake = take

Gibt eine Funktion zurück, die ein Argument akzeptiert. Daher gibt es keinen Grund, das Argument explizit einzugeben, es sei denn, Sie möchten dies auch.

Hier ist ein Beispiel in TypeScript ohne andere Bibliothek:

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

Sie können sehen, dass der punktfreie Stil "fließender" und leichter zu lesen ist.