La mia comprensione limitata è tale:
1) Applicazione di funzioni parziali
Applicazione di funzioni parziali è il processo di restituzione di una funzione che richiede un numero minore di argomenti. Se fornisci 2 argomenti su 3, restituirà una funzione che richiede 3-2 = 1 argomento. Se fornisci 1 argomento su 3, restituirà una funzione che richiede 3-1 = 2 argomenti. Se lo volevi, 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 vincoli da 1 a x e in parte lo applichi alla funzione precedente f(x,y,z) otterrai:
f(1,y,z) = f'(y,z);
Dove: f'(y,z) = 1 + y + z;
Ora se dovessi associare 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, puoi 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
Currying d'altra parte è il processo di divisione di una funzione in una catena nidificata di funzioni di un argomento. Non puoi mai fornire più di 1 argomento, è uno o zero.
Quindi ha la stessa funzione:
f(x,y,z) = x + y + z;
Se lo curasti, 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);
Viene restituita una nuova funzione:
g(y) = 1 + f''(y);
Se chiami g(y) con y = 2 :
g(2) = 1 + 2 + f'''(z);
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 restituito 6 .
3) Chiusura
Infine, Closure è il processo di acquisizione di una funzione e di dati insieme come una singola unità. Una chiusura di funzione può richiedere da 0 a un numero infinito di argomenti, ma è anche a conoscenza dei dati non passati ad esso.
Di nuovo, 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 su x . Significa che f' può leggere il valore di x che è all'interno di f .
Quindi se dovessi chiamare f con x = 1 :
f(1) = 1 + f'(y, z);
Avresti una chiusura:
closureOfF(y, z) =
var x = 1;
f'(y, z);
Ora se hai chiamato closureOfF con y = 2 e z = 3 :
closureOfF(2, 3) =
var x = 1;
x + 2 + 3;
Quale restituirebbe 6
Conclusione
Il currying, l'applicazione parziale e le chiusure sono in qualche modo simili in quanto decompongono una funzione in più parti.
Currying decompone una funzione di più argomenti in funzioni annidate di singoli argomenti che restituiscono funzioni di singoli argomenti. Non ha senso inserire una funzione di uno o meno argomento, poiché 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 per il valore fornito.
Closure 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 da associare quando viene richiesto di valutare.
Ciò che è confuso da tutto ciò è che possono essere usati per implementare un sottoinsieme degli altri. Quindi, in sostanza, sono tutti un dettaglio di implementazione. Offrono tutti un valore simile in quanto non è necessario raccogliere tutti i valori in anticipo e in quanto è possibile riutilizzare parte della funzione, poiché è stata decomposta in unità discrete.
La divulgazione
Non sono affatto un esperto dell'argomento, solo di recente ho iniziato a conoscerli e quindi fornisco le mie conoscenze attuali, ma potrebbero avere degli errori che ti invito a sottolineare, e correggerò come / se ne scopro.