La mia comprensione limitata è tale:
1) Applicazione con funzioni parziali
L'applicazione di funzione parziale è il processo di restituzione di una funzione che accetta un numero minore di argomenti. Se si forniscono 2 argomenti su 3, verrà restituita una funzione che accetta 3-2 = 1 argomento. Se si forniscono 1 su 3 argomenti, verrà restituita una funzione che accetta 3-1 = 2 argomenti. Se lo desideri, potresti anche applicare parzialmente 3 argomenti su 3 e restituirebbe una funzione che non accetta argomenti.
Quindi, data la seguente funzione:
f(x,y,z) = x + y + z;
Quando si associa 1 a x e si applica parzialmente quello alla funzione sopra f(x,y,z)si otterrà:
f(1,y,z) = f'(y,z);
Dove: f'(y,z) = 1 + y + z;
Ora se dovessi legare y a 2 e z a 3 e applicare parzialmente f'(y,z)otterrai:
f'(2,3) = f''();
Dove f''() = 1 + 2 + 3:;
Ora in qualsiasi momento, è possibile scegliere di valutare f, f'o f''. Quindi posso fare:
print(f''()) // and it would return 6;
o
print(f'(1,1)) // and it would return 3;
2) Currying
D' altra parte, il processo di suddivisione di una funzione in una catena nidificata di funzioni di un argomento è al contrario. Non puoi mai fornire più di 1 argomento, è uno o zero.
Quindi, data la stessa funzione:
f(x,y,z) = x + y + z;
Se lo mettessi al curry, otterrai una catena di 3 funzioni:
f'(x) -> f''(y) -> f'''(z)
Dove:
f'(x) = x + f''(y);
f''(y) = y + f'''(z);
f'''(z) = z;
Ora se chiami f'(x)con x = 1:
f'(1) = 1 + f''(y);
Ti viene restituita una nuova funzione:
g(y) = 1 + f''(y);
Se chiami g(y)con y = 2:
g(2) = 1 + 2 + f'''(z);
Ti viene restituita una nuova funzione:
h(z) = 1 + 2 + f'''(z);
Infine se chiami h(z)con z = 3:
h(3) = 1 + 2 + 3;
Sei tornato 6.
3) Chiusura
Infine, la chiusura è il processo di acquisizione di una funzione e di dati come un'unica unità. Una chiusura di una funzione può portare da 0 a un numero infinito di argomenti, ma è anche consapevole dei dati che non le sono stati passati.
Ancora una volta, data la stessa funzione:
f(x,y,z) = x + y + z;
Puoi invece scrivere una chiusura:
f(x) = x + f'(y, z);
Dove:
f'(y,z) = x + y + z;
f'è chiuso il x. Significa che f'può leggere il valore di x che è dentro f.
Quindi se dovessi chiamare fcon x = 1:
f(1) = 1 + f'(y, z);
Avresti una chiusura:
closureOfF(y, z) =
var x = 1;
f'(y, z);
Ora se hai chiamato closureOfFcon y = 2e z = 3:
closureOfF(2, 3) =
var x = 1;
x + 2 + 3;
Che sarebbe tornato 6
Conclusione
Currying, applicazione parziale e chiusure sono in qualche modo simili in quanto scompongono una funzione in più parti.
Currying decompone una funzione di più argomenti in funzioni nidificate di singoli argomenti che restituiscono funzioni di singoli argomenti. Non ha senso valutare una funzione di uno o meno argomenti, dal momento che non ha senso.
L'applicazione parziale decompone una funzione di più argomenti in una funzione di argomenti minori i cui argomenti ora mancanti sono stati sostituiti con il valore fornito.
La chiusura decompone una funzione in una funzione e un set di dati in cui le variabili all'interno della funzione che non sono state passate possono guardare all'interno del set di dati per trovare un valore a cui associarsi quando viene chiesto di valutare.
La cosa che confonde di tutto ciò è che possono essere usati per implementare un sottoinsieme degli altri. Quindi, in sostanza, sono tutti un po 'dettagli di implementazione. Forniscono tutti un valore simile in quanto non è necessario raccogliere tutti i valori in anticipo e in quanto è possibile riutilizzare parte della funzione, poiché è stata scomposta in unità discrete.
Divulgazione
Non sono affatto un esperto dell'argomento, solo recentemente ho iniziato a conoscerli e quindi fornisco la mia attuale comprensione, ma potrebbe avere errori che ti invito a sottolineare e correggerò come / se Ne scopro qualcuno.