Ciò che è “libero punto” stile (in programmazione funzionale)?

Question

Una frase che ho notato di recente è il concetto di "point gratuito" stile ...

In primo luogo, c'era questa domanda , e < a href = "https://stackoverflow.com/questions/907306/confusion-about-currying-and-point-free-style-in-haskell"> anche questo .

Poi, ho scoperto qui accennano "Un altro argomento che potrebbe essere la pena di discutere è antipatia degli autori di free style punto ".

Che cosa è "libero punto" stile? Qualcuno può dare una spiegazione concisa? Ha qualcosa a che fare con accattivarsi "automatico"?

Per avere un'idea del mio livello - Ho insegnato io stesso schema, e ho scritto un semplice interprete Scheme ... capisco cosa "implicito" currying è, ma io non conosco nessun Haskell o ML <. / p>

Answer 1

Basta guardare la Wikipedia articolo per ottenere la vostra definizione:

  

programmazione Tacit (programmazione libera-punto) è un paradigma di programmazione in cui una definizione di funzione non includono le informazioni riguardanti i suoi argomenti, utilizzando combinatori e composizione funzione [...] invece di variabili.

Haskell esempio:

convenzionale (si specificano gli argomenti in modo esplicito):

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

(sum non ha argomenti espliciti - è solo una piega con + iniziando con 0) senza Point:

 sum = foldr (+) 0

O ancora più semplice:. Invece di g(x) = f(x), si può solo scrivere g = f

Quindi sì: E 'strettamente legato al currying (o operazioni come la composizione funzione)

.

Answer 2

stile libero-Point significa che gli argomenti della funzione in corso di definizione non sono esplicitamente menzionati, che la funzione è definita attraverso la composizione di funzione.

Se si dispone di due funzioni, come

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

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

e se si desidera combinare queste due funzioni a uno che calcola x*x+1, è possibile definirla "point-pieno" in questo modo:

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

L'alternativa senza punto non sarebbe per parlare del x argomento:

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

Answer 3

Un campione 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'

Riferimento

Answer 4

free style punto significa che il codice non prevede esplicitamente menzione è argomenti, anche se esistono e vengono utilizzati.

Questo funziona in Haskell a causa del lavoro funzioni modo.

Per esempio:

myTake = take

restituisce una funzione che prende un argomento, quindi non v'è alcun motivo di tipo esplicito l'argomento meno che non vogliate semplicemente troppo.

Answer 5

Ecco un esempio a macchina, senza alcuna altra libreria:

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

Si può vedere stile libero-punto è più "fluida" e più facile da leggere.