Was ist ein „Punkt frei“ Art (in Functional Programming)?

Question

Eine Phrase, die ich bemerkt habe vor kurzem ist das Konzept des „Punktes frei“ Stil ...

Zuerst gibt es diese Frage und < a href = "https://stackoverflow.com/questions/907306/confusion-about-currying-and-point-free-style-in-haskell"> auch dieses .

Dann entdeckte ich sie erwähnen „Ein weiteres Thema, das diskutiert wert sein kann, die Abneigung der Autoren von Punkt freien Stil. "

Was ist „Punkt frei“ Stil? Kann jemand eine kurze Erklärung geben? Hat es etwas mit „Automatik“ currying zu tun?

Um eine Vorstellung von meinem Niveau zu bekommen - ich habe mich unterrichtet Schema, und habe ein einfaches Schema Interpreter geschrieben ... Ich verstehe, was „implizite“ Striegeln, aber ich kenne keine Haskell oder ML <. / p>

Answer 1

Schauen Sie sich die Wikipedia-Artikel Ihre Definition zu erhalten:

  

Tacit Programmierung (Punkt-freie Programmierung) ist ein Programmierparadigma, in dem eine Funktionsdefinition enthält keine Informationen ihre Argumente in Bezug auf, unter Verwendung von Kombinatoren und Funktion Zusammensetzung [...] anstelle von Variablen.

Haskell Beispiel:

Konventionell (Sie die Argumente explizit angeben):

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

Punkt frei (sum keine expliziten Argumente hat - es ist nur eine Falte mit + beginnend mit 0):

 sum = foldr (+) 0

Oder noch einfacher:. Statt g(x) = f(x), könnten Sie einfach g = f schreiben

Also ja: Es ist eng mit currying (oder Operationen wie Funktionszusammensetzung) im Zusammenhang

.

Answer 2

Punkt-freie Art bedeutet, dass die Argumente der Funktion nicht explizit erwähnt definiert ist, dass die Funktion durch Funktion Zusammensetzung definiert ist.

Wenn Sie zwei Funktionen, wie

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

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

, und wenn Sie diese beiden Funktionen zu einem kombinieren möchten, die x*x+1 berechnet, können Sie es „Punkt-voll“ wie folgt definiert werden:

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

Der Punkt freie Alternative wäre nicht mit dem Argument x zu sprechen:

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

Answer 3

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

Answer 4

Punkt freier Stil bedeutet, dass der Code nicht explizit erwähnt, dass es Argumente gibt, auch wenn sie vorhanden ist und verwendet werden.

Das funktioniert in Haskell wegen der Art und Weise Funktionen arbeiten.

Zum Beispiel:

myTake = take

eine Funktion zurückgibt, die ein Argument, daher gibt es keinen Grund zu der expliziten Typ das Argument, es sei denn Sie einfach zu wollen.

Answer 5

Hier ist ein Beispiel in Typoskript ohne jede 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 sehen Punkt frei Stil ist „fließend“ und leichter zu lesen.