La programmation fonctionnelle correspond au modèle de programmation qui est basé sur le concept d'énoncer la procédure d'un programme comme un modèle fonctionnel mathématique plutôt que comme des séquences explicites d'instructions à un processeur, qui est le concept principal de la programmation impérative.
Le langage fonctionnel met l'accent sur les déclarations et les termes plutôt que sur l'exécution d'instructions. Dans cette programmation, le résultat ne dépendra que des paramètres passés à une fonction, contrairement aux autres types qui obéissent à un état local ou global.
Son nom vient des fonctions mathématiques, qui sont l'affectation d'un ensemble d'entrées à un ensemble de sorties. Une fonction mathématique ne fait pas vraiment de travail, mais décrit le modèle d'un processus, expliquant au moyen d'une formule ce qu'un ensemble d'entrées produit dans une fonction.
Index des articles
La base sur laquelle reposait la programmation fonctionnelle était le calcul lambda, qui a été développé au cours de la troisième décennie du 20e siècle pour définir et appliquer des fonctions. LISP a été le premier langage de programmation du genre, conçu en 1960.
Bien que la plupart des langages de programmation se composent d'entrées, de sorties et de variables externes qui peuvent être définies ou utilisées à partir de fonctions, la programmation fonctionnelle évite cela. L'idée est que chaque fois qu'une fonction est appelée avec les mêmes paramètres, elle doit renvoyer la même valeur.
Les langages de programmation fonctionnels sont appelés applications, car les fonctions sont appliquées à leurs paramètres, ainsi que déclaratives et non procédurales, car les définitions spécifient ce qui doit être calculé et non comment il est calculé..
Une fonction est pure lorsqu'elle n'a pas d'effets secondaires observables, tels que la modification de variables externes, des changements dans le système de fichiers, etc..
Ces fonctions sont considérées comme convaincantes, car elles ne modifieront pas expressément les variables dont d'autres parties du code pourraient dépendre à un moment donné. Il semblerait difficile de coder avec ces restrictions, mais ces fonctions doivent être considérées comme déterministes, prévisibles et composables..
Les fonctions sont considérées comme des valeurs pouvant être affectées à des variables, de sorte qu'elles peuvent être transmises et renvoyées par d'autres fonctions. Autrement dit, une fonction peut être utilisée comme s'il s'agissait d'un paramètre ou comme une valeur renvoyée.
Cela implique que la fonction peut être transmise en tant que telle, plutôt que simplement le résultat de la fonction. Par exemple, considérons la fonction double (x), qui renvoie deux fois la valeur de son paramètre d'entrée. Ainsi, double (2) renverrait 4.
Comme il s'agit d'une fonction de première classe, le code (double (double (2)) serait le même que le code double (4). Cela vous permet d'imbriquer une fonction en tant que paramètre d'une autre, etc..
Il fait référence au fait que dans ce modèle de programmation, il n'y a pas d'instructions d'affectation. Autrement dit, de nouvelles variables doivent être définies si vous souhaitez stocker des valeurs supplémentaires. Par conséquent, l'état d'une variable est constant à tout moment.
Cela élimine la moindre possibilité d'effets indésirables, car toute variable peut être remplacée par sa valeur réelle à n'importe quel point d'exécution du programme..
En programmation fonctionnelle, il n'y a pas de boucles «for» et «while». Au lieu de cela, l'itération repose sur la récursivité. La récursivité est implémentée à l'aide de fonctions récursives, qui s'appellent elles-mêmes de manière répétitive jusqu'à ce que le cas de base soit atteint.
Les variables sont immuables, c'est-à-dire qu'il n'est pas possible de modifier une variable une fois qu'elle a été initialisée. Bien qu'une nouvelle variable puisse être créée, la modification des variables existantes n'est pas autorisée.
Avec un exemple, vous pouvez analyser la différence entre ces approches, en effectuant la même opération dans les deux arrangements, qui consiste à filtrer les nombres impairs d'une liste en remplaçant 5 par des nombres pairs inférieurs à 5.
C'est le même calcul, avec le même résultat. Cependant, comme vous pouvez le voir, le code impératif est détaillé et pas immédiatement clair. D'autre part, l'approche déclarative est lisible et explicite, car elle se concentre sur ce que vous voulez obtenir.
Ce qui est défini comme des fonctions pures et impures peut être clarifié avec quelques exemples de base:
Cela signifie utiliser les fonctions de la même manière que les données. Par conséquent, ils peuvent être passés en tant que paramètres à une autre fonction. Dans l'exemple suivant, la fonction int peut être transmise en tant que paramètre à la fonction map:
>>> liste (carte (int, ["1", "2", "3"]))
[1, 2, 3]
Ils peuvent être affectés à des variables et renvoyés. Par exemple, dans le code suivant, vous pouvez affecter la fonction hello_world, puis exécuter la variable en tant que fonction.
- Concentrez-vous sur ce que vous voulez réaliser (déclaratif) et non sur comment y parvenir (impératif).
- Ils ne contiennent pas d'instructions d'affectation, donc une fois que les variables reçoivent une valeur, elles ne changeront plus. Par conséquent, les programmes fonctionnels ne contiennent pas d'effets secondaires.
- Le flux logique est clair, car l'état est moins dispersé et n'est pas modifié implicitement.
- Prend en charge le concept d'évaluation paresseuse, ce qui signifie que la valeur n'est évaluée et stockée qu'en cas de besoin.
- Puisque les fonctions pures ne changent aucun état et dépendent complètement de l'entrée, elles sont faciles à comprendre. La valeur de retour donnée par ces fonctions est la même que le résultat produit par elles.
- En raison de la nature des fonctions pures pour éviter que les variables ou toute donnée externe changent, la mise en œuvre de la concurrence est efficace.
- Les fonctions sont traitées comme des valeurs, transmises à d'autres fonctions comme des paramètres. Cela améliore la compréhension et la lisibilité du code..
- Les fonctions pures prennent les paramètres une fois, produisant une sortie immuable. L'utilisation de valeurs inaltérables facilite le débogage et les tests.
Ils sont plus courts et plus faciles à comprendre que les impératifs. Des études ont montré que la productivité moyenne des programmeurs en termes de lignes de code est plus ou moins la même pour n'importe quel langage de programmation, ce qui se traduit par une productivité plus élevée..
L'appel d'une fonction ne peut pas avoir un effet différent du calcul de son résultat. Cela exclut une source importante d'erreurs, rendant également l'ordre d'exécution non pertinent, car aucun effet secondaire ne pourra changer la valeur d'une expression, et elle peut être évaluée à tout moment.
Le programmeur est soulagé de la charge d'établir un flux de contrôle. Les expressions pouvant être évaluées à tout moment, les variables peuvent être remplacées par leurs valeurs.
Cette autonomie favorise que les programmes fonctionnels soient plus gérables mathématiquement que les programmes conventionnels..
- Le paradigme de la programmation fonctionnelle n'est pas simple, ce qui le rend difficile à comprendre pour un débutant.
- Il est difficile à maintenir, car de nombreux objets évoluent lors de l'encodage.
- Dans certains cas, l'écriture de fonctions pures entraîne une réduction de la lisibilité du code.
- Les valeurs immuables associées à la récursivité peuvent entraîner une réduction drastique des performances du système.
- La réutilisation est très compliquée et nécessite une refactorisation constante.
- Ecrire des programmes dans un style récursif au lieu d'utiliser des boucles ou des boucles peut être une tâche très ardue..
- Les objets peuvent ne pas représenter correctement le problème.
- Bien que l'écriture de fonctions pures s'avère facile, les combiner avec le reste de l'application et avec les opérations d'entrée / sortie est assez difficile
La programmation de l'intelligence artificielle est effectuée dans des langages de programmation fonctionnels et les techniques d'intelligence artificielle migrent vers des applications du monde réel.
Il excelle également dans la mise en œuvre de modèles mathématiques complexes. Pour cette raison, l'une des principales utilisations des langages fonctionnels a été traditionnellement académique. Il est utile pour développer des spécifications exécutables et des implémentations de prototypes.
De nombreux langages fonctionnels excellent également dans la mise en œuvre du traitement parallèle. Cela est dû à sa capacité à tirer parti des fonctions pures, qui renvoient toujours la même valeur quel que soit l'ordre dans lequel elles sont exécutées..
WhatsApp utilise le langage de programmation Erlang, qui suit le modèle de programmation fonctionnelle, permettant ainsi à plus d'une centaine de ses employés de gérer les données appartenant à quelque 1,6 milliard de personnes..
Un autre support important du style de programmation fonctionnelle est Haskell. Il est utilisé par Facebook dans son système antispam. Même JavaScript, l'un des langages de programmation les plus utilisés, affiche les propriétés d'un langage fonctionnel de type dynamique.
Il a été conçu après C ++, obtenant tous ses avantages tout en éliminant ses faiblesses observées de devoir être compatible avec C.
Il est hautement évolutif et simultané, ce qui le rend idéal pour les télécommunications et autres applications qui reçoivent des quantités massives de données dans un ordre imprévisible..
Il s'agit d'un pur langage de programmation fonctionnel, qui utilise le calcul Lambda.
Il est utilisé dans des applications mathématiques, scientifiques, financières, analytiques et autres. L'une de ses forces est de créer des logiciels pour gérer d'autres programmes.
C'est un langage open source basé sur Caml. Il a tendance à créer des programmes très légers, les aidant à se charger et à s'exécuter plus rapidement que ceux créés par d'autres langages.
Il est basé sur la syntaxe LISP et la structure ALGOL. En raison de sa simplicité, il est utilisé dans de nombreux cours d'informatique comme une introduction à la conception de programmes pour montrer certains des principes fondamentaux de la programmation informatique..
Personne n'a encore commenté ce post.