Ma compréhension limitée est telle:
1) Application de fonction partielle
Application de fonction partielle est le processus de retour d'une fonction qui prend un nombre d'arguments inférieur. Si vous fournissez 2 arguments sur 3, une fonction prenant 3-2 = 1 argument sera renvoyée. Si vous fournissez 1 argument sur 3, il retournera une fonction prenant 3-1 = 2 arguments. Si vous le souhaitez, vous pouvez même appliquer partiellement 3 arguments sur 3 et renvoyer une fonction qui ne prend aucun argument.
Donc, étant donné la fonction suivante:
f(x,y,z) = x + y + z;
En liant 1 à x et en appliquant partiellement cela à la fonction ci-dessus, f(x,y,z)vous obtenez:
f(1,y,z) = f'(y,z);
Où: f'(y,z) = 1 + y + z;
Maintenant, si vous liez y à 2 et z à 3 et appliquiez partiellement, f'(y,z)vous obtiendriez:
f'(2,3) = f''();
Où: f''() = 1 + 2 + 3;
Maintenant, à tout moment, vous pouvez choisir d’évaluer f, f'ou f''. Donc je peux faire:
print(f''()) // and it would return 6;
ou
print(f'(1,1)) // and it would return 3;
2) curry
Le curry , d’autre part, est le processus consistant à diviser une fonction en une chaîne imbriquée de fonctions à un argument. Vous ne pouvez jamais fournir plus d'un argument, c'est un ou zéro.
Donc, étant donné la même fonction:
f(x,y,z) = x + y + z;
Si vous le faisiez curry, vous auriez une chaîne de 3 fonctions:
f'(x) -> f''(y) -> f'''(z)
Où:
f'(x) = x + f''(y);
f''(y) = y + f'''(z);
f'''(z) = z;
Maintenant, si vous appelez f'(x)avec x = 1:
f'(1) = 1 + f''(y);
Vous êtes renvoyé une nouvelle fonction:
g(y) = 1 + f''(y);
Si vous appelez g(y)avec y = 2:
g(2) = 1 + 2 + f'''(z);
Vous êtes renvoyé une nouvelle fonction:
h(z) = 1 + 2 + f'''(z);
Enfin si vous appelez h(z)avec z = 3:
h(3) = 1 + 2 + 3;
Vous revenez 6.
3) fermeture
Enfin, la fermeture est le processus de capture d’une fonction et de données en une seule unité. Une fermeture de fonction peut prendre 0 à un nombre infini d'arguments, mais elle est également consciente des données qui ne lui sont pas transmises.
Encore une fois, étant donné la même fonction:
f(x,y,z) = x + y + z;
Vous pouvez plutôt écrire une fermeture:
f(x) = x + f'(y, z);
Où:
f'(y,z) = x + y + z;
f'est fermé sur x. Signification qui f'peut lire la valeur de x qui se trouve à l'intérieur f.
Donc, si vous appelez favec x = 1:
f(1) = 1 + f'(y, z);
Vous obtiendrez une fermeture:
closureOfF(y, z) =
var x = 1;
f'(y, z);
Maintenant, si vous avez appelé closureOfFavec y = 2et z = 3:
closureOfF(2, 3) =
var x = 1;
x + 2 + 3;
Qui reviendrait 6
Conclusion
Currying, application partielle et fermetures sont toutes assez similaires en ce sens qu'elles décomposent une fonction en plusieurs parties.
Currying décompose une fonction de plusieurs arguments en fonctions imbriquées d’arguments uniques qui renvoient des fonctions d’arguments uniques. Il ne sert à rien de traiter une fonction d'un argument ou moins, car cela n'a aucun sens.
L'application partielle décompose une fonction de plusieurs arguments en une fonction de petits arguments dont les arguments manquants ont été substitués à la valeur fournie.
Closure décompose une fonction en une fonction et un jeu de données dans lequel les variables de la fonction qui n'ont pas été passées peuvent regarder à l'intérieur du jeu de données pour trouver une valeur à lier lorsqu'elles sont invitées à évaluer.
Ce qui est déroutant à propos de tout cela, c'est qu'ils peuvent en quelque sorte être utilisés pour implémenter un sous-ensemble des autres. Donc, essentiellement, ils sont tous un peu un détail de mise en œuvre. Ils offrent tous une valeur similaire en ce sens qu'il n'est pas nécessaire de rassembler toutes les valeurs à l'avance et que vous pouvez réutiliser une partie de la fonction, car vous l'avez décomposée en unités discrètes.
Divulgation
Je ne suis en aucun cas un expert du sujet, je n’ai que récemment commencé à en apprendre davantage sur ce sujet, et j’exprime donc mes connaissances actuelles, mais il pourrait y avoir des erreurs que je vous invite à signaler, et je corrigerai si / si Je découvre tout.