Les caractéristiques de Haskell

Paradigme de programmation

Haskell est un langage fonctionnel pur.

Il adopte donc le paradigme de la programmation fonctionnelle, dans une forme plutôt stricte. Cette approche interdit¹ notamment les effets de bord dans les fonctions, ainsi que la ré-affectation des variables. Ces variables sont en effet, par défaut, non mutables, ce qui peut s’avérer déroutant pour les adeptes de langages impératifs.

On peut donc voir cette approche de la programmation par le prisme des pratiques qu’elle prohible par rapport à la programmation impérative. Mais si l’on précise ce qui est prohibé par l’adoption relativement stricte de ce paradigme fonctionnel, il est juste d’également préciser ce qu’elle permet en contrepartie.

Comme dans tous les langages (plus ou moins) fonctionnels, les fonctions y sont de première catégorie (on peut par exemple définir des variables contenant des fonctions). On peut donc y manipuler les fonctions notamment, en les affectant a des variables, de façon beaucoup plus souple que dans des langages impératifs.

On peut également construire des fonctions complexes par combinaison de fonctions plus simples (avec l’opérateur .). Plus fort, on peut déconstruire des fonctions par le mécanisme de l’application partielle. On peut encore évoquer la définition de fonctions par correspondance de motifs (pattern matching).

Langage compilé

Les programmes réalisés en Haskell sont généralement destinés à être compilés en exécutables natifs, à l’instar de langages comme le C ou le C++.

Cette approche est plus lourde en termes d’outillage, car elle impose au programmeur ou à la programmeuse de disposer d’un compilateur et de savoir s’en servir, ou de disposer d’un système de construction (build) qui sait s’en servir. Elle impose également de définir la plateforme ciblée par le programme (Linux, Window, Android…) et de procéder à des compilations distinctes pour chacune des plateformes ciblées si l’on souhaite une diffusion sur plusieurs d’entre elles.

Mais l’étape de compilation permet en contrepartie d’éliminer de nombreuses erreurs potentielles en amont de la diffusion du programme auprès de ses utilisateur·ices. De plus, les exécutables natifs qui en résultent constituent la forme la plus performante possible que puisse revêtir un programme.

Système de types

Haskell est un langage statiquement typé et fortement typé.

Cela signifie que le respect des types pour valoriser des variables ou des arguments de fonctions y est contrôlé de façon stricte par le compilateur. En outre, le langage ne se livre pas à des conversions automatiques de types comme on peut en voir dans d’autres langages (par exemple quand on affecte une valeur numérique à une variable chaîne de caractères en Javascript ou un int à un long en langage C).

Les conversions de valeurs d’un type vers un autre peuvent évidemment exister en Haskell. Mais elles doivent alors être explicites, en utilisant des fonctions de conversion plutôt que de simples affectations.

Par rapport à une approche plus dynamiquement typée, qui a également ses adeptes, le typage statique opte donc pour plus de rigueur, au prix d’une moindre souplesse. Le programmeur ou la programmeuse ne peut pas faire tout ce qu’iel veut aussi simplement qu’iel pourrait le désirer, mais cela l’empêche également de faire n’importe quoi par mégarde ou par ignorance.

Système de types très expressif

En plus d’être statique et fort, ajoutons que le système de types de Haskell est particulièrement expressif. Les types peuvent y être dotés de multiples constructeurs, être paramétrés avec d’autres types et se conformer à des interfaces communes à certains d’entre eux.

Haskell pousse naturellement à faire grand usage des types de données algébriques, concept particulièrement puissant.

À ce titre, on notera que le langage Haskell en comporte pas de référence nulle, telle que la valeur null du langage C et de ses héritiers. On peut cependant utiliser le type paramétrable Maybe pour définir explicitement qu’une valeur peut être non définie.

Évaluation paresseuse (par défaut)

En Haskell les différentes valeurs manipulées par un programme, notamment celles résultant de l’exécution de fonctions, sont évaluées de façon paresseuse (lazy evaluation). C’est à dire qu’elles sont réellement évaluées (avec le coût de calcul que cela implique) non pas au moment où elles sont définies dans le programme, mais de façon différée au moment ou la valeur y est concrètement utilisée.

Par rapport à une évaluation plus classique (dite stricte), cela implique une autre forme de compromis entre l’utilisation de la ressource calcul et celle de la ressource mémoire :

• Une évaluation paresseuse peut consommer plus de mémoire, car des expressions intermédiaires doivent être mémorisées qui permettront l’évaluation le moment venu.

  Si l’on prend l’exemple d’une fraction, une évaluation paresseuse impliquera de mémoriser le numérateur et le dénominateur plutôt que le résultat de la division (donc deux nombres au lieu d’un seul) jusqu’à ce que l’évaluation différée de la division soit effectivement exécutée.

• En contrepartie, l’évaluation paresseuse peut économiser du temps de calcul. Le fait que l’évaluation d’une valeur soit différée au moment de son utilisation implique une optimisation par construction qui est que seule les valeurs effectivement utilisées sont évaluées.

  Imaginons par exemple un programme qui charge les données d’une liste de personnes et que l’une des propriétés de chacune de ces personnes soit son âge calculé à partir de sa date de naissance et de la date du jour. Avec un langage à évaluation stricte, à moins que l’on prenne un soin particulier à rédiger du code pour l’éviter, l’âge de chacune des personnes sera calculé au chargement de la liste, qu’il soit utilisé ou non par la suite dans l’exécution du programme. Avec son évaluation paresseuse, le même programme écrit en Haskell ne calculera l’âge que pour les personnes pour lesquelles on l’utilise effectivement (par exemple quand l’utilisateur·ice consulte la fiche d’une personne, une parmi des centaines peut être).

En quoi cette combinaison particulière de caractéristiques rend Haskell intéressant

Chacune des caractéristiques exposées dans la section précédente peut se révéler intéressante en tant que telle, considérée séparément des autres. Mais cela peut être sujet à débat, plusieurs d’entre elles présentant des compromis entre des aspects intéressants et des contraintes qui les accompagnent.

Mais c’est surtout le « cocktail » qui résulte de l’association de ces différentes caractéristiques qui rend Haskell particulièrement intéressant.

• L’association de la pureté fonctionnelle, du typage statique fort et de l’étape de compilation qui permet une détection précoce des erreurs en s’appuyant sur ces autres caractéristiques donne au langage un très fort penchant pour la rigueur.

  Avec la plupart des langages de programmation, même compilés, quand un programme compile le programmeur ou la programmeuse expérimenté·e sait qu’il y a encore potentiellement loin de la coupe aux lèvres pour avoir un programme qui fonctionne correctement. On a juste passé l’étape de la résolution des erreurs qui pouvaient être détectées à la compilation, mais l’on sait qu’il reste à trouver toutes celles qui ne se manifestent qu’à l’exécution… et elles peuvent être nombreuses et sournoises.

  Avec Haskell, le niveau de confiance que l’on peut avoir pour un programme qui compile est considérablement plus élevé (sans être absolu). La structure même du langage vous aura interdit de coder tout un tas d’erreurs qui peuvent être monnaie courante avec d’autres langages. Ensuite, la compilation vous aura détecté la plupart des petites incohérences qui auraient pu vous échapper.

  Une fois la compilation achevée, il reste très peu de place pour l’occurence d’erreurs arithmétiques (comme par exemple le fait de déréférencer une référence non définie, cause de toutes les NullPointerException du monde Java). Restent alors (seulement) les erreurs fonctionnelles, qui résultent généralement d’une mauvaise compréhension par le programmeur ou la programmeuse ou par l’analyste du problème à résoudre. Mais contre cela, aucun langage de programmation ne peut rien.

  Cette synergie de caractéristiques qui tend à considérablement réduire à la source le nombre de bugs pouvant survenir est probablement le principal point fort de Haskell. Cela est particulièrement appréciable à une ère où la principale plaie de l’industrie informatique est justement qu’elle croule sous les bugs.

• La pureté fonctionnelle entraîne la transparence référentielle, qui à son tour permet la mémoïsation des appels de fonctions. Ainsi le moteur d’exécution peut de son propre chef mémoriser le résultat du premier appel d’une fonction avec un jeu donné de valeurs d’arguments pour le réutiliser en lieu et place des prochains appels similaires. Il s’agit d’une optimisation ici automatisée alors qu’elle nécessite habituellement un travail spécifique du programmeur ou de la programmeuse utilisant des langages impératifs.

  Associons à cette mémoïsation l’évaluation paresseuse et nous obtenons des programmes avec un niveau déjà avancé d’optimisation, sans que cela ait coûté quoi que ce soit en temps de développement.

Domaines d’application

Haskell jouit d’une communauté non négligeable d’adeptes qui en sont généralement des pratiquants particulièrement convaincus. Mais ce n’est très clairement pas le langage de programmation le plus pratiqué au monde.

Notons en outre que si, comme tout langage turing complete, il peut théoriquement tout faire, il brille cependant particulièrement dans certains domaines d’application ; moins dans d’autres. Mais c’est là le lot de tous les langages de programmation.