TL; DR
La programmazione funzionale riguarda le chiusure e le loro applicazioni. A meno che qualcuno non sia in grado di mostrarti una libreria di chiusura di discesa per C, dimentica di usare C per imparare la programmazione funzionale.
Cos'è la programmazione funzionale?
Il concetto cardine della programmazione funzionale è la nozione di chiusure che, in termini approssimativi, catturano una funzione insieme a associazioni di variabili. Oltre all'uso pervasivo delle chiusure, ci sono alcuni altri tratti distintivi nella programmazione funzionale, come l'uso di funzioni ricorsive e valori immutabili (entrambi giocano bene insieme). Questi tratti sono più un problema culturale che altro, e non esiste alcun ostacolo tecnico per usarli praticamente in qualsiasi lingua, per questo mi concentro sulle chiusure nella mia risposta: non tutte le lingue consentono di creare facilmente chiusure.
Tre illustrazioni sull'utilità delle chiusure
Un uso tipico delle chiusure è l'implementazione di meccanismi di privacy. Ad esempio il codice Javascript - negli esempi ho scelto Javascript perché è un linguaggio funzionale con una cosiddetta "sintassi simil-C" e la tua domanda suggerisce che hai familiarità con C:
create_counter = function()
{
var x = 0;
var counter = function()
{
++x;
return x;
};
return counter;
}
Quindi con
a = create_counter();
b = create_counter();
abbiamo due funzioni ae contiamo braccolte disgiunte. Il punto dell'esempio è che le variabili xvengono catturate dalla chiusura che definisce la counterchiusura e ogni volta che una nuova counterchiusura is instantiated by the function, it gets its fresh own idea of whatè x`.
Un altro uso tipico delle chiusure è la definizione di applicazioni parziali di funzioni. Supponiamo che abbiamo una struttura di reporting simile syslogall'implementazione di una funzione
var log = function(priority, message) {
…
};
dove gli argomenti prioritye messagesi pensano che siano stringhe, il primo è uno dei "debug", "info"e così via. Possiamo definire una fabbrica di tronchi come questa:
var logWithPriority = function(priority) {
return function(message) {
log(priority, message);
};
};
e utilizzarlo per definire versioni specializzate della nostra funzione di registro:
var debug = logWithPriority("debug");
var info = logWithPriority("info");
…
Questo è molto utile, perché invece di scrivere in forquesto modo soggetti a errori
for(i = 0; i < journal.length; ++i) {
log("info", journal[i]);
}
possiamo scrivere in modo più pulito, più breve e molto più semplice (non c'è i, è molto meglio):
journal.forEach(logWithPriority("info"));
Un terzo importante campo di applicazione delle chiusure è l'implementazione della valutazione pigra - si noti che il supporto linguistico speciale può fornire una migliore implementazione.
Una funzione pigra, invece di eseguire un calcolo diretto, restituisce una chiusura che può essere chiamata (o "forzata" nel gergo della pigrizia) per eseguire la domanda. La motivazione per fare ciò è che separa la preparazione di un calcolo e l'esecuzione di un calcolo. Un esempio pratico di ciò è la compilazione di espressioni regolari: se un programma compila molte espressioni regolari al momento dell'avvio, avrà bisogno di molto tempo per avviarsi. Se invece compiliamo pigramente le espressioni regolari e le forziamo quando ne abbiamo bisogno, allora il nostro programma può iniziare rapidamente. Naturalmente, le espressioni regolari possono essere sostituite qui con qualsiasi struttura che richieda un considerevole tempo di inizializzazione.
Ecco come implementare la valutazione pigra con le chiusure. Considera l'implementazione classica della funzione arrayMax che restituisce il massimo in un array:
function arrayMax(array) {
return array.reduce(function(a, b) {
return Math.min(a, b);
};
}
La variante pigra sarebbe:
function arrayMax(array) {
var memo = null;
function actuallyCompute() {
if(memo === null) {
memo = array.reduce(function(a, b) {
return Math.min(a, b);
});
}
return memo;
}
return actuallyCompute;
}
Il valore restituito è una chiusura che può essere utilizzata per calcolare il valore o recuperarlo un'altra volta se è già stato calcolato.
Con questi tre esempi, dovremmo essere certi che le chiusure e le loro applicazioni sono il nucleo della programmazione funzionale.
Conclusione
Imparare la programmazione funzionale significa imparare a programmare con le chiusure. Di conseguenza, le lingue che consentono la facile manipolazione delle chiusure, e in particolare l'applicazione parziale delle funzioni, dovrebbero essere considerate quando si cerca una lingua per studiare la programmazione funzionale. Al contrario, le lingue in cui le chiusure non possono essere facilmente manipolate sarebbero scelte sbagliate.