Programmation fonctionnelle expliquée en 5 minutes [avec exemples]

La création d'un logiciel est un processus très technique et difficile qui nécessite une planification et une stratégie pour formuler la bonne façon de résoudre un problème à l'aide du logiciel.

À cet égard, considérer le paradigme de programmation de choix avant de développer un logiciel est une étape importante.

Un paradigme de programmation est un modèle ou une approche de la programmation qui fournit des fonctionnalités, des modèles, des principes, des règles et des styles de conception, de structuration et d'écriture de programmes informatiques.

Des exemples de paradigmes de programmation populaires incluent la programmation orientée objet (POO), la programmation procédurale, la programmation événementielle et la programmation fonctionnelle, entre autres.

La programmation fonctionnelle, en particulier, a beaucoup retenu l'attention ces derniers temps car elle promet moins de code bogué, hautement réutilisable et facile à entretenir. Qu'est-ce donc que la programmation fonctionnelle ?

La programmation fonctionnelle est un sous-paradigme du paradigme de la programmation déclarative. La programmation déclarative est un paradigme qui se concentre sur l'écriture de code qui décrit ce qu'un programme doit faire plutôt que comment le programme doit le faire.

Un exemple de cela peut être vu lors de l'interrogation des bases de données SQL pour les données. Au lieu de dire explicitement comment vous voulez que cela soit récupéré, tout ce que vous spécifiez, ce sont les données que vous voulez récupérer.

La programmation fonctionnelle elle-même est un paradigme pour la construction de programmes informatiques utilisant des expressions et des fonctions pures qui sont appliquées en séquence pour résoudre des problèmes ou obtenir les résultats souhaités.

Dans la programmation fonctionnelle, toute la fonctionnalité d'un programme est décomposée en fonctions pures réutilisables et à responsabilité unique. Tout dans le programme passe par l'utilisation de fonctions pures.

Une fonction pure est une fonction déterministe qui, lorsqu'elle reçoit les mêmes valeurs d'entrée, renverra la même sortie et n'affectera aucune autre partie des applications.

Le résultat d'une fonction pure repose donc uniquement sur son entrée et non sur une variable globale dans l'application qui peut modifier les résultats de la fonction.

Ces fonctions pures reçoivent des entrées, les traitent localement et produisent une sortie sans altérer aucune autre partie du programme.

La programmation fonctionnelle utilise des données immuables, c'est-à-dire des données qui ne peuvent pas être modifiées une fois créées, et évite également les états partagés, où les mêmes données peuvent être consultées et modifiées par différentes parties d'un programme.

Étant donné que la programmation fonctionnelle repose fortement sur les fonctions, les fonctions sont qualifiées de citoyens de première classe, ce qui signifie qu'elles peuvent être transmises en tant qu'argument, enregistrées dans une variable et également renvoyées par une autre fonction.

De plus, la programmation fonctionnelle s'appuie fortement sur l'expression plutôt que sur les instructions et évite ainsi les instructions de boucle telles que pour le , tout en. Ceci est fait pour rendre la logique du programme facile à suivre et à déboguer.

Types of Functional Programming Languages

Il existe deux principaux types de langages de programmation fonctionnels. Ceux-ci inclus:

• Langages purement fonctionnels – Ce sont des langages de programmation qui prennent en charge, appliquent et promeuvent l'utilisation de paradigmes fonctionnels tels que l'utilisation de fonctions pures de première classe, l'immuabilité des états et des données, et les fonctions n'ayant pas d'effets secondaires sur d'autres parties du programme. Des exemples de langages purement fonctionnels incluent Haskell, Agda, Clean, Idris, Futhark et Elm, entre autres.
• Langages fonctionnels impurs – Ce sont des langages qui prennent en charge les paradigmes de programmation fonctionnelle mais permettent également l'utilisation de fonctions impures, les mutations de l'état d'un programme et les opérations qui ont des effets secondaires. Des exemples de langages fonctionnels impurs incluent Javascript, Rust, Erlang, Python, Rubi, java, Kotlin, et Clojure, entre autres.

Des langages fonctionnels purement fonctionnels et impurs sont utilisés par les développeurs. Cependant, passer à un langage purement fonctionnel peut prendre beaucoup de temps et d'efforts si vous n'avez jamais utilisé la programmation fonctionnelle auparavant.

Functional Programming Languages and Libraries

Certains langages de programmation fonctionnels et bibliothèques populaires incluent :

# 1. Haskell

Haskell est un langage de programmation statiquement typé, paresseux et purement fonctionnel qui est considéré comme l'incarnation du paradigme de la programmation fonctionnelle.

En plus de l'inférence de type, le langage offre un support pour l'évaluation paresseuse, où les expressions ne sont évaluées que lorsque leurs résultats sont nécessaires. Haskell offre également un support pour la programmation simultanée, et sa compilation est livrée avec un ramasse-miettes hautes performances et une bibliothèque de concurrence légère.

Grâce à son utilisation et à son strict respect des principes de programmation fonctionnelle, Haskell peut faciliter la création de systèmes logiciels complexes et en faciliter la maintenance.

Parmi de nombreux acteurs de l'industrie, Haskell est le langage de référence lors de la création de systèmes autonomes ou de langages spécifiques à un domaine. Il est également largement utilisé dans le milieu universitaire et la recherche. Certaines entreprises qui utilisent Haskell incluent Microsoft, Github, Hasura et Lumi, parmi beaucoup d'autres.

# 2. Dans le cadre

Dans le cadre est une bibliothèque de programmation fonctionnelle pour le langage JavaScript. Ramda simplifie la construction d'une logique complexe grâce à la composition fonctionnelle et fournit un ensemble de fonctions utilitaires qui encouragent et prennent en charge l'utilisation des principes de programmation fonctionnelle en JavaScript.

Ramda fournit également un moyen simple d'utiliser des objets et des fonctions immuables sans effets secondaires, qui sont des concepts clés de la programmation fonctionnelle.

Étant donné que JavaScript n'est pas un langage de programmation purement fonctionnel comme Haskell, grâce à l'utilisation d'une bibliothèque comme Ramda, vous pouvez utiliser la programmation fonctionnelle et profiter des avantages de performance de la programmation fonctionnelle tout en utilisant JavaScript.

# 3. Élixir

Élixir est un langage de programmation fonctionnel, simultané et à usage général, conçu pour être évolutif, facile à entretenir et également tolérant aux pannes. La langue a été créée en 2011 par Jose Valim, fonctionne sur le BEAM machine virtuelle, et est utilisé par des entreprises comme Heroku, Discord, change.org et Duffel, entre autres.

En tant que langage de programmation fonctionnel, Elixir encourage l'immuabilité des états et des données, l'utilisation de fonctions pures lors de l'écriture de code et la transformation des données.

Key Concepts in Functional Programming

# 1. Fonctions pures

La programmation fonctionnelle utilise largement les fonctions pures. Les fonctions pures ont deux caractéristiques principales. Premièrement, ils produisent le même résultat pour le même intrant, quels que soient les facteurs externes, ce qui les rend déterministes par nature et donc prévisibles.

Deuxièmement, les fonctions pures n'ont pas d'effets secondaires. C'est-à-dire qu'ils ne modifient en aucune façon l'environnement extérieur hors de leur champ d'application.

Voici quelques exemples de fonctions pures :

//function to calculate the square of a number
function square(x) {
    return x * x;
}

//function to add two variables
function add(a, b) {
    return a + b
}

Les fonctions ci-dessus renvoient la même sortie pour les mêmes entrées et n'ont aucun effet secondaire en dehors de leur portée.

# 2. Immutabilité

En programmation fonctionnelle, les données utilisées sont immuables. Cela signifie qu'une fois les variables initialisées, elles ne peuvent plus être modifiées. Cela garantit la préservation de l'état d'une variable tout au long du programme.

Si vous souhaitez apporter une modification à la variable ou effectuer une opération dessus, vous pouvez créer une nouvelle variable pour stocker les données mises à jour sans modifier la variable initiale.

# 3. Fonctions d'ordre supérieur

Les fonctions d'ordre supérieur sont des fonctions qui acceptent une ou plusieurs fonctions comme arguments et/ou renvoient une fonction.

Les fonctions d'ordre supérieur sont utiles dans la programmation fonctionnelle car elles permettent de combiner plusieurs fonctions pour créer de nouvelles fonctions, permettent l'utilisation de rappels, permettent l'abstraction de modèles communs en fonctions réutilisables, et enfin, les fonctions d'ordre supérieur permettent l'écriture de plus concis et code expressif.

Un exemple de fonction d'ordre supérieur est illustré ci-dessous :

// A higher-order function which returns a function that multiplies
// a number by a given factor
function multiplier(factor) {
    return function (number) {
      return number * factor;
    }
  }
  
const double = multiplier(2); 
const triple = multiplier(3);
const quadruple = multiplier(4);
  
console.log(double(5)); // Output: 10
console.log(triple(5)); // Output: 15
console.log(quadruple(5)); // Output: 20

# 4. Récursivité

Étant donné que la programmation fonctionnelle repose sur des expressions au lieu d'instructions, les instructions de flux de contrôle telles que les boucles for et while sont évitées dans ce paradigme. Ces instructions de boucle sont, à leur tour, remplacées par la récursivité, qui est utilisée pour effectuer des itérations dans la programmation fonctionnelle.

La récursivité implique qu'une fonction s'appelle elle-même à plusieurs reprises jusqu'à ce qu'une condition de sortie soit remplie. En utilisant la récursivité, un problème complexe est décomposé en sous-problèmes plus petits et plus simples qui sont ensuite résolus de manière récursive jusqu'à ce qu'un cas de base soit atteint, fournissant une solution au problème complexe plus vaste.

# 5. Programmation déclarative

La programmation fonctionnelle est un sous-paradigme du paradigme de programmation déclarative plus large qui englobe les paradigmes de programmation qui se concentrent sur l'écriture de code en termes de ce qui doit être fait au lieu d'indiquer explicitement comment le faire.

À cet égard, lorsque vous utilisez le paradigme de la programmation fonctionnelle, votre code doit décrire ce qui doit être réalisé ou le problème à résoudre.

La manière dont cela sera réalisé dépend du langage de programmation que vous utilisez. Cela aide à écrire un code plus concis et facilement lisible.

# 6. Apatride

La programmation fonctionnelle met l'accent sur le code sans état, où le code ne maintient pas un état global qui peut être modifié par des fonctions. Les résultats des fonctions reposent uniquement sur l'entrée transmise et ne peuvent pas être influencés par des dépendances sur d'autres parties du code.

Les fonctions utilisées ne peuvent pas modifier un état ou une variable du programme hors de sa portée.

# 7. Exécution parallèle

Étant donné que la programmation fonctionnelle utilise des états immuables, utilise des fonctions pures et des données immuables, elle permet l'exécution parallèle de plusieurs calculs simultanément.

Étant donné que chaque fonction ne doit traiter qu'une entrée donnée sans se soucier des effets secondaires d'autres parties d'un programme, les problèmes complexes peuvent être divisés en sous-problèmes plus petits et exécutés simultanément en parallèle, ce qui permet d'améliorer les performances et l'efficacité.

Benefits of Functional Programming

Certains des avantages de la programmation fonctionnelle incluent :

Moins de bugs logiciels

Outre le fait que le code implémentant le paradigme de la programmation fonctionnelle est plus lisible et plus facile à comprendre grâce à l'utilisation de fonctions pures, la programmation fonctionnelle permet d'écrire du code avec moins d'erreurs.

Étant donné que la programmation fonctionnelle fonctionne avec des états immuables, vous n'avez jamais plusieurs parties d'un programme modifiant l'état d'une variable ou du programme entier. Ceci, à son tour, réduit le nombre d'erreurs qui auraient pu résulter de la modification de données à partir de plusieurs zones en raison d'états partagés.

Améliore la lisibilité du code

La programmation fonctionnelle est un sous-paradigme du paradigme déclaratif, qui met l'accent sur l'écriture de code décrivant ce qui doit être fait plutôt que comment le faire. Ceci, associé à l'utilisation de fonctions pures, donne un code explicite, plus facile à lire et à comprendre et facile à entretenir.

Améliorer la réutilisabilité du code

La mise en œuvre de la programmation fonctionnelle nécessite de décomposer des problèmes complexes en sous-problèmes plus petits et de résoudre ces problèmes à l'aide de fonctions pures. Ces fonctions peuvent facilement être composées et réutilisées pour résoudre d'autres problèmes complexes. Grâce à l'utilisation de fonctions pures et d'états immuables, la programmation fonctionnelle permet l'écriture de code hautement réutilisable.

Test et débogage plus faciles

La programmation fonctionnelle utilise des fonctions pures qui n'ont pas d'effets secondaires, ne dépendent que de leurs entrées et produisent des sorties déterministes cohérentes pour le même ensemble d'entrées.

Cela rend la programmation fonctionnelle intrinsèquement facile à tester et à déboguer, car vous n'avez pas besoin de suivre une variable et son évolution dans les différentes parties d'un programme.

Puisqu'il n'y a pas de dépendances dans la programmation fonctionnelle, le débogage et les tests deviennent plus faciles car vous pouvez cibler des parties spécifiques d'un programme.

Prend en charge la concurrence et le parallélisme

Étant donné que la programmation fonctionnelle encourage l'apatridie et l'immuabilité des données, elle permet d'exécuter en toute sécurité plusieurs fonctions pures en parallèle ou simultanément. La capacité d'exécuter plusieurs opérations en parallèle se traduit par de meilleures vitesses de traitement et une meilleure utilisation des processeurs à plusieurs cœurs.

En tant que paradigme de programmation, la programmation fonctionnelle peut aider à l'écriture d'un code plus lisible et facilement compréhensible avec moins d'erreurs et un excellent support pour le parallélisme permettant une utilisation efficace des processeurs multicœurs. La programmation fonctionnelle permet la construction de systèmes logiciels plus fiables et faciles à mettre à l'échelle.

Limitations of Functional Programming

Bien que la programmation fonctionnelle ait beaucoup à offrir, elle s'accompagne d'une courbe d'apprentissage qui oblige les développeurs à investir beaucoup de temps et d'efforts pour apprendre à utiliser le paradigme. En effet, il introduit de nouvelles façons de structurer le code et de nouveaux concepts de programmation.

Le codage à l'aide de la programmation fonctionnelle peut être extrêmement complexe et difficile car il n'utilise pas de fonctionnalités plus intuitives telles que les boucles for et while. Écrire des programmes de manière récursive n'est pas facile.

En conséquence, les développeurs peuvent prendre plus pour maîtriser la programmation fonctionnelle, en particulier lorsqu'ils proviennent de langages qui utilisent des états mutables, comme dans la programmation orientée objet.

Une autre limitation de la programmation fonctionnelle provient de son principe fondamental d'immuabilité. Étant donné que les données et les états sont modifiables et que de nouvelles structures de données sont créées au lieu de modifier celles existantes, cela se traduit par une programmation fonctionnelle utilisant plus d'espace de stockage. La nature immuable de la programmation fonctionnelle peut également entraîner une baisse des performances des applications.

Conclusion

Bien que la programmation fonctionnelle existe depuis longtemps, elle est devenue un paradigme tendance ces derniers temps. Même si cela peut être un peu difficile à comprendre, les développeurs bénéficieront énormément de l'apprentissage du paradigme et des différentes façons dont ils peuvent implémenter la programmation fonctionnelle lors de l'écriture de programmes.

Comme vous n'avez pas besoin d'utiliser des langages de programmation purement fonctionnels tels que Haskell, vous pouvez implémenter des concepts de programmation fonctionnelle dans des langages tels que Javascript, Java, Python et Kotlin et profiter des avantages de la programmation fonctionnelle dans vos projets.

Vous pouvez également explorer certains ressources pour apprendre Python pour les débutants.