TL; DR
La programmation fonctionnelle concerne les fermetures et leurs applications. À moins que quelqu'un ne puisse vous montrer une bibliothèque de fermeture de descente pour C, oubliez d'utiliser C pour apprendre la programmation fonctionnelle.
Qu'est-ce que la programmation fonctionnelle?
Le concept cardinal de la programmation fonctionnelle est la notion de fermetures qui, grosso modo, capture une fonction avec des liaisons de variables. Outre l'utilisation généralisée des fermetures, il existe quelques autres traits distinctifs dans la programmation fonctionnelle, comme l'utilisation de fonctions récursives et de valeurs immuables (les deux jouent bien ensemble). Ces traits sont plus un problème culturel qu'autre chose, et il n'y a pas d'obstacle technique pour les utiliser dans pratiquement toutes les langues, c'est pourquoi je me concentre sur les fermetures dans ma réponse: toutes les langues ne permettent pas de créer facilement des fermetures.
Trois illustrations de l'utilité des fermetures
Une utilisation typique des fermetures est la mise en œuvre de mécanismes de confidentialité. Par exemple, le code Javascript - dans les exemples, j'ai choisi Javascript parce que c'est un langage fonctionnel avec une soi-disant «syntaxe de type C» et votre question suggère que vous êtes familier avec C:
create_counter = function()
{
var x = 0;
var counter = function()
{
++x;
return x;
};
return counter;
}
Puis avec
a = create_counter();
b = create_counter();
nous avons deux fonctions aet comptons les bcollections disjointes. Le point de l'exemple est que les variables xsont capturées par la fermeture définissant la counterfermeture et chaque fois qu'une nouvelle counterfermeture is instantiated by the function, it gets its fresh own idea of whatx` l'est.
Une autre utilisation typique des fermetures est la définition d'applications partielles de fonctions. Supposons que nous avons une fonction de reporting similaire à la syslogmise en œuvre d'une fonction
var log = function(priority, message) {
…
};
où les arguments priorityet messagedevraient être des chaînes, le premier étant l' un "debug", "info"et ainsi de suite. Nous pouvons définir une fabrique de journaux comme celle-ci:
var logWithPriority = function(priority) {
return function(message) {
log(priority, message);
};
};
et l'utiliser pour définir des versions spécialisées de notre fonction de journalisation:
var debug = logWithPriority("debug");
var info = logWithPriority("info");
…
C'est très utile, car au lieu d'écrire des forboucles sujettes aux erreurs comme celle-ci
for(i = 0; i < journal.length; ++i) {
log("info", journal[i]);
}
on peut écrire le plus propre, le plus court et le plus simple (il n'y en a pas i, c'est bien mieux):
journal.forEach(logWithPriority("info"));
Un troisième champ d'application important des fermetures est la mise en œuvre de l'évaluation paresseuse - notez que la prise en charge d'un langage spécial peut permettre une meilleure mise en œuvre.
Une fonction paresseuse, au lieu d'effectuer un calcul simple, renvoie une fermeture qui peut être appelée (ou «forcée» dans le jargon de la paresse) pour effectuer la question. La motivation pour ce faire est qu'il sépare la préparation d'un calcul et l'exécution d'un calcul. Un exemple pratique de ceci est la compilation d'expressions régulières: si un programme compile beaucoup d'expressions régulières au démarrage, il aura besoin de beaucoup de temps pour démarrer. Si au lieu de cela nous compilons paresseusement les expressions régulières et les forçons comme nous en avons besoin, alors notre programme peut démarrer rapidement. Bien sûr, les expressions régulières peuvent être remplacées ici par toute structure nécessitant un temps d'initialisation considérable.
Voici comment implémenter une évaluation paresseuse avec des fermetures. Considérons l'implémentation classique de la fonction arrayMax retournant le max dans un tableau:
function arrayMax(array) {
return array.reduce(function(a, b) {
return Math.min(a, b);
};
}
La variante paresseuse serait:
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;
}
La valeur renvoyée est une fermeture qui peut être utilisée pour calculer la valeur ou la récupérer une autre fois si elle a déjà été calculée.
Avec ces trois exemples, nous devons être convaincus que les fermetures et leurs applications sont au cœur de la programmation fonctionnelle.
Conclusion
Apprendre la programmation fonctionnelle signifie apprendre à programmer avec des fermetures. En conséquence, les langages permettant la manipulation aisée des fermetures, et notamment l'application partielle de fonctions, doivent être pris en compte lors de la recherche d'un langage pour étudier la programmation fonctionnelle. Inversement, les langues où les fermetures ne peuvent pas être facilement manipulées seraient de mauvais choix.