Présentation du langage Haskell

[kaukau]

Salut à tous !

Voici un petit article pour présenter Haskell aux novices en programmation
fonctionnelle (comme moi) et surtout, pour vous donner l'envie d'en savoir
plus.

Haskell est un langage généraliste récent (moins d'une dizaine d'années),
il introduit une foule de concepts extremement intéressants. Il est
malheureusement encore peu utilisé dans le monde industriel. Mais il vaut le détour !!

Quelques infos pour vous donner envie de lire la suite :
- 10 fois moins de lignes de code qu'en C,
- une grande expressivité, une grande généricité,
- une compréhension, une maintenabilité du code largement accrue,
- très peu de bugs grâce à son système de types évolué!

C'est un langage basé sur une théorie mathématique (la théorie de
catégories). Ce langage est « fonctionnel pur », par opposition aux
langages « impératifs », dont font parties tous les langages les plus
connus (C, C++, Ada, Java, Pascal…).
Cela induit un mode de programmation radicalement différent !
Le "gap sémantique" à franchir est important, ce qui en fait un language
plutôt difficile à apprendre pour quelqu'un comme moi qui vient du monde
impératif, mais le jeu en vaux la chandelle.

Haskell est :

- paresseux
- pleinement fonctionnel
- fortement typé, et supporte l'inférence de type
- pur


Haskell est effectivement paresseux, mais ce n'est pas péjoratif !
Cela signifie qu'il n'évalue pas une expression si ce n'est pas
nécessaire. Si le résultat d'un calcul n'est pas utilisé dans la suite
du programme, il n'est pas évalué.

Cela induit un gain évident en terme de temps de traitement.
Cela améliore aussi le design des programmes puisque cela décharge le
programmeur de coder certaines optimisations, pour se concentrer sur
le métier de son logiciel.

Mais surtout, cela permet de faire certaines abstractions très
intéressantes : comme par exemple des structures de données de taille
infinie.
En Haskell il est tout à fait possible de déclarer un « tableau » de
taille infinie, par exemple une tableau contenant tous les éléments de
la suite de Fibonacci !
Bien sûr vous choisirez de n'afficher que les n premiers éléments, et
Haskell décidera de ne calculer que ceux là. (Voir l'exemple
faramineux de wikipedia: http://fr.wikipedia.org/wiki/Haskell)


Ensuite Haskell est pleinement fonctionnel : les fonctions sont des
objets de « 1ere classe ».
Cela signifie que les fonctions peuvent être traitées comme des
variables. Donc une fonction peut être passée en paramètre à une autre
fonction, récupérée en paramètre de retour etc.

Haskell supporte les fonctions anonymes et les fonctions « lambda ».
Cela permet par exemple de décrire une fonction (simple) dans la zone
de paramètres d'une autre fonction.
Un bon exemple vaut mieux qu'un long discours :

map (+1) [1..10]

map est une fonction à 2 arguments : une fonction et une liste (ici
[1..10]). Comme on peut s'y attendre, map applique la fonction à tous
les éléments de la liste et retourne une liste résultante.
Mais mais mais ??? « (+1) » c'est une fonction ? Eh bien oui, c'est
une fonction anonyme (je ne l'ai pas déclarée avec un petit nom).

Et la fonction « + » prend bien 2 arguments ? Je n'en voit qu'un (le 1
dans l'exemple)? Il s'agit du mécanisme d' « évaluation partielle » de
Haskell.
Si vous avez une fonction de 2 paramètres et que vous
fournissez les 2 paramètres, c'est super.
Mais si vous ne fournissez qu'un paramètre, le résultat de l'opération
sera… Une fonction bien sur ! Une fonction de l'autre paramètre.
Et cette fonction à un paramètre est ce qu'attend la fonction map.

Quizz: quel est le résultat de cette ligne de code ?


Haskell supporte la curryfication. Cette opération, du nom de son
inventeur, est à la base d'Haskell. D'ailleurs, devinez le prénom de
ce Mr Curry… Haskell bien sur !!


Il existe bien sùr une algèbre sur les fonctions : l'addition, la composition…
Vous pouvez donc définir une fonction en une ligne par simple
composition de deux autres fonctions à l'aide de l'opérateur rond « °
». Ce qui rend les choses assez lisible : dans un gros programme les
fonctionnalités de haut niveau sont souvent cassés en plusieurs
fonctions plus simple. Une fois définis les fonctions simples, vous
les ressemblez en une ligne avec l'opérateur rond.


Haskell est statiquement et fortement typé.
Le système de typage est très évolué, et vous évitera de nombreuses erreurs
de programmation.
Une fois que votre programme compile (ce qui peut prendre un certain
temps...) vous pouvez pratiquement être sur qu'il marche!
En effet le typage est très fort et filtrera de nombreuses erreurs de logique.
Grâce au système d'inférence de types, vous pouvez vous épargner la peine
d'écrire les types de vos fonctions. Le compilateur déduira lui-même le type le plus général.


Je termine par le plus dur :
Haskell est un langage fonctionnel « pur ».
Cela signifie qu'il n'y a aucuns effets de bords, et donc qu'il ne
supporte pas l'affectation.

Par exemple dans un programme en C, je pourrais avoir l'instruction suivante :

a = f + g

f et g sont des fonctions, a un entier.
Dans le cadre d'un refactoring, je pourrais être amené à vouloir écrire :

a = g + f

Eh bien ce n'est à priori pas possible. En C comme dans d'autres
langages, les fonctions ont des effets de bord : f peut modifier le
contexte qui sera utilisé par g.

En Haskell, le retour d'une fonction dépend uniquement de ses
paramètres, de rien d'autre. Si vous l'appelez à n'importe quel moment
avec les mêmes paramètres, le résultat sera le même.
Cela donne une très grande plasticité et maintenabilité au programme.
Tout devient plus clair !
Mais il faut reconnaître que les programmes sont plus difficiles à écrire.

Cette aspect « pas d'affectation » ouvre la porte à de nombreuses
fonctionnalités impossible sans, dont la paresse.
A noter aussi que comme conséquence, l'ordre des instructions n'a pas
d'importance… Haskell est uniquement déclaratif.

Haskell intègre aussi de nombreuses autres fonctionnalités que je n'ai
malheureusement pas le temps de développer ici, dont :
- la compréhension de listes
- le pattern matching pour les paramètres
- les monades et les classes de types…



Références :
www.haskell.org
http://en.wikipedia.org/wiki/Haskell...ming_language))

Ouvrages de référence :
Yet Another Haskell Tutorial
A Gentle Introduction to Haskell

La traduction en Français par Nicolas Vallée (alias Gorgonite):
A Gentle Introduction to Haskell, version 98

Contrairement à ce que son nom indique, ce dernier ouvrage n'est pas
gentil du tout , je vous conseille plutôt de commencer par :
Haskell for C Programmers

J'ai fait une traduction en Français de ce dernier ouvrage:
Tutorial Haskell pour le développeur C

Corentin DUPONT (Kau)

[InOCamlWeTrust]

Non.

A Gentle Introduction to Haskell a été traduit par des membres de ce forum même. Je ne me souviens plus de l'adresse où se trouve la traduction ; gorgonite, qui est celui ayant mené à bien le travail, peut en fournir le lien.

Contrairement à une idée répandue, y compris sur le HaskellWiki dont le post ci-dessus en est le résumé ou la traduction de la présentation, ce document est le meilleur pour commencer, essentiellement dû au fait que c'est le plus concis et le plus clair sur le sujet.

[gorgonite]

Envoyé par InOCamlWeTrust

A Gentle Introduction to Haskell a été traduit par des membres de ce forum même. Je ne me souviens plus de l'adresse où se trouve la traduction ; gorgonite, qui est celui ayant mené à bien le travail, peut en fournir le lien.

http://gorgonite.developpez.com/livr...entle-haskell/

Envoyé par InOCamlWeTrust

Contrairement à une idée répandue, y compris sur le HaskellWiki dont le post ci-dessus en est le résumé ou la traduction de la présentation, ce document est le meilleur pour commencer, essentiellement dû au fait que c'est le plus concis et le plus clair sur le sujet.

de quoi parles-tu ?
le gentle serait bien pour un type totalement novice en prog fontionnelle ?

[kaukau]

Lorsque je me suis intéressé à Haskell, j'ai ouvert le gentle et franchement, je n'ai rien compris!!
Il faut dire que je suis totalement novice en prog fonctionnel.

J'ai donc essayé de résumer les fonctionnalité qui m'ont plu dans Haskell et dans les languages fonctionnels dans le post ci-dessus.
Je suis en train de traduire un tutoriel plus accessible à mon sens: Haskell for C programmer.

[InOCamlWeTrust]

Le gros avantage du Gentle Introduction est qu'il ne compare pas Haskell à ce qui se fait avec d'autres langages, fonctionnels ou non. Il aborde Haskell en tant que tel, et n'essaye pas de transposer des idées, ce qui n'est pas réellement une bonne chose, à mon avis.

Apprendre un langage fonctionnel, c'est aussi s'accaparer la manière dont on raisonne en fonctionnel, qui est parfois très éloignée de ce qui se fait en impératif.

Bref, moi j'ai commencé par ça, et ça ne m'a absolument pas paru difficile... mais c'est vrai, j'avais beaucoup de OCaml derrière moi.

Ce qui, par contre, peut paraître déroutant, c'est tous ces trucs propres à Haskell et que l'on ne retrouve nulle part ailleurs : les motifs paresseux, les classes de types, les monades, etc... Ce genre de chose, mêlées au reste, peut effectivement être un obstacle si on n'a aucune notion d'un quelconque langage fonctionnel.

On peut dire, sans trop se tromper, que le noyau stable de Haskell est plus gros que celui des langages fonctionnels standards : OCaml, Scheme, Lisp, etc... c'est peut-être ce qui fait sa difficulté, tout avaler d'un coup !

[SpiceGuid]

Entièrement d'accord avec InOCamlWeTrust, éluder la nouveauté en insistant sur ce qui se rapproche de ce que l'on connaît déjà c'est la meilleure façon de ne rien apprendre.

Une bonne façon c'est:

• tout introduire à partir de rien, en insistant plus sur la sémantique que sur la syntaxe
• illustrer avec des exemples non triviaux pour montrer que les nouveaux concepts dépassent le cadre du cas d'école, qu'ils sont à leur manière aussi effectifs que ce qui est déjà connu
• ne même pas comparer avec un autre langage, c'est inutile car le lecteur se fera lui même son opinion

EDIT:

Je viens de jeter un coup d'oeil sur le lien de gorgonite:

• félicitations pour le travail de traduction, XIV chapitres pas évidents tout de même
• évidemment si on connaît déjà Miranda il n'y a pas grand chose de nouveau, donc je ne peux pas juger, mais quand même A Gentle Introduction to Haskell me paraît un peu abrupt pour le débutant complet
• je reste néanmoins sur mes positions, sinon qu'est-ce qu'on fait après Haskell for C Programmers ? Haskell for Java Programmers ? Haskell for Delphi Programmers ? Haskell for Python Programmers ? Avec ce type d'approche on en fini jamais de ne pas progresser.

[InOCamlWeTrust]

Haskell for Bash programmers !

[gorgonite]

Envoyé par SpiceGuid

• félicitations pour le travail de traduction, XIV chapitres pas évidents tout de même

on était deux... je n'ai en fait que 8
en gros, je mets entre 1 et 2 soirées pour un chapitre, donc c'est rapide... comme quoi l'épreuve de version de taupe a fini par servir à quelque chose

Envoyé par SpiceGuid

• évidemment si on connaît déjà Miranda il n'y a pas grand chose de nouveau, donc je ne peux pas juger, mais quand même A Gentle Introduction to Haskell me paraît un peu abrupt pour le débutant complet

perso, je ne l'ai pas encore entièrement assimilé... pourtant j'ai joué avec pas mal de langages fonctionnels, et je connais les grandes techniques de compilation associées

Envoyé par SpiceGuid

• je reste néanmoins sur mes positions, sinon qu'est-ce qu'on fait après Haskell for C Programmers ? Haskell for Java Programmers ? Haskell for Delphi Programmers ? Haskell for Python Programmers ? Avec ce type d'approche on en fini jamais de ne pas progresser.

je trouve qu'il peut y avoir un intérêt dans ces approches, si la comparaison entre les paradigmes est efficace... en Haskell for C/Java/Prolog Programmers (choississez les langages que vous préférez en procédural, impératif objet, déclaratif)

[kaukau]

SpiceGuid :
Lorsque tu attaque un nouveau champ de connaissances, tu le compare toujours avec ce que tu connais!!
Ca me parait un peu extrémiste de rejeter ça
Tout comprendre ex-nihilo c'est franchement une autre paire de manche!!
L'approche par comparaisons est très efficace à mon sens.

[SpiceGuid]

Entre deux paradigmes différents la comparaison est pédagogiquement inefficace. Elle n'est utile que pour les théoriciens qui compareront à loisir les classes avec les fonctionnelles et/ou avec les types sommes, ce qui ne fera qu'embrouiller un peu plus le débutant.

A Gentle Introduction to Haskell est abrupt parce que:

• changer de paradigme est plus difficile que changer de langage
• il y manque les exemples non triviaux qui dépassent le cadre du cas d'école et introduisent le lecteur à la pratique réelle du nouveau paradigme

[gorgonite]

Envoyé par SpiceGuid

Entre deux paradigmes différents la comparaison est pédagogiquement inefficace. Elle n'est utile que pour les théoriciens qui compareront à loisir les classes avec les fonctionnelles et/ou avec les types sommes, ce qui ne fera qu'embrouiller un peu plus le débutant.

je ne suis que très partiellement d'accord... je ne vois pas pourquoi cela ne sert à rien de s'inspirer du paradigme fonctionnel dans des langages plus classiques
or on ne peut le faire si l'on n'effectue pas parfois quelques comparaisons

[Garulfo]

Envoyé par InOCamlWeTrust

Le gros avantage du Gentle Introduction est qu'il ne compare pas Haskell à ce qui se fait avec d'autres langages, fonctionnels ou non. Il aborde Haskell en tant que tel, et n'essaye pas de transposer des idées, ce qui n'est pas réellement une bonne chose, à mon avis.

Apprendre un langage fonctionnel, c'est aussi s'accaparer la manière dont on raisonne en fonctionnel, qui est parfois très éloignée de ce qui se fait en impératif.[...]

Je suis aussi d'accord avec Spice Guid et IOCWT. A priori, faire une approche par comparaison/analogie peut sembler une bonne idée pour lancer un débutant. Cependant, on se rend compte qu'alors il continue à penser impératif et à traduire.

C'est un peu comme essayer de parler anglais en pensant en français puis en traduisant. N'importe quel linguiste peut vous dire que ça ne marche pas. On continue à penser en français et être incapable de parler correctement. C'est la même chose pour les paradigmes de programmation.

N'avez jamais vous vu Star Wars ? Luke devra désapprendre avant de réapprendre correctement. La Force et le Paradigme fonctionnel même combat

[benwit]

Alp m'a donnée envie d'en apprendre un peu plus sur ce langage ...

La courte intro de kaukau ne freine pas cette envie ...
Comme lui, je pense d'un côté que cela peut être instructif des comparaisons pour des trucs simples.

Après, c'est sûr, je comprend également le point de vue inverse (combien j'ai vue de personne utiliser un langage objet et faire du procédural / et les personnes qui avaient du mal avec prolog, lisp)

A comparer avec d'autres langages/styles, certes, il peut y avoir des risques mais je pense que ça dépend aussi des individus (on peut savoir prendre du recul quand même).

Exprimé autrement, Haskell et les nouveaux concepts dont vous parlez ne sont pas apparus par enchantement, ils sont bien arrivés parce que quelqu'un a entrevu d'autres possibilités, des manques dans d'autres langages (fusse t'il fonctionnel ?)
Le cerveau humain a quand même tendance à passer d'un état "Je ne connais pas" à un état "Je connais" en oubliant toute cette phase d'apprentissage.

Et pour vous provoquer un peu , ça permet de quoi faire ces langages fonctionnels à part des trucs de matheux ?
Pendant mes études, j'ai fait un peu de lisp et j'ai adoré l'esprit ...
mais là, sans avoir creusé, j'ai du mal à voir comment les langages fonctionnels s'interfacent avec l'utilisateur ? Il n'y a que des batchs/lignes de commandes ?

Et toi, Alp, qu'en penses tu ? faut-il tout reprendre de zéro au risque de ne pas "entrer dedans" ? ou utiliser la passerelle quitte à l'abandonner par la suite ?
Et toi, Garulfo, maitre Yoda, comment moi, petit scarabée, je fait pour désapprendre la programmation objet ?

[Alp]

Envoyé par benwit

Et pour vous provoquer un peu , ça permet de quoi faire ces langages fonctionnels à part des trucs de matheux ?

Tout... Il y a des éditeurs faits en Haskell, il y a une API pour communiquer avec twitter, il y a un serveur d'applis web "à la J2EE" pour Haskell, bref énormément de choses. Un petit aperçu ici : http://hackage.haskell.org/packages/pkg-list.html

Envoyé par benwit

Pendant mes études, j'ai fait un peu de lisp et j'ai adoré l'esprit ...

Tu as une petite base commune, mais on ne peut pas dire que Haskell et Lisp jouent dans la même cour.

Envoyé par benwit

mais là, sans avoir creusé, j'ai du mal à voir comment les langages fonctionnels s'interfacent avec l'utilisateur ? Il n'y a que des batchs/lignes de commandes ?

Non. Tu verras dans le lien que j'ai donné ci-dessus qu'il y a N bibliothèques pour le GUI, il y a des bindings OpenGL, GLUT, ... Il y a vraiment beaucoup de bibliothèques.

Envoyé par benwit

Et toi, Alp, qu'en penses tu ? faut-il tout reprendre de zéro au risque de ne pas "entrer dedans" ? ou utiliser la passerelle quitte à l'abandonner par la suite ?

Bah j'avais fait à peine un peu d'OCaml quand j'ai attaqué Haskell. Et tant bien que mal, je m'en suis sorti. Le tout c'est de ne pas être réfractaire à autre chose que l'OO, ou je ne sais quoi. L'OO c'est un paradigme parmi tant d'autres.

Je pense qu'épiloguer pour te convaincre ne sera pas aussi efficace que le fait que toi-même tu t'essayes à apprendre Haskell et à le mettre en pratique, petit à petit.

Bon courage

[SpiceGuid]

Envoyé par benwit

comment moi, petit scarabée, je fait pour désapprendre la programmation objet ?

Pense aux types.

Un extrait pris sur mon blog:

Vu d'une certaine façon, le catalogue des design patterns n'est qu'une longue énumération des inconvénients à penser dans le cadre d'un paradigme plutôt qu'à utiliser le type qui convient pour l'usage qui convient.

La programmation fonctionnelle ça n'est pas un autre paradigme, c'est juste des langages plus (et mieux) typés qui te donnent vraiment les moyens d'améliorer ton style.
À la base gorgonite, Alp, InOCamlWeTrust, moi, je pense qu'on est des programmeurs impératifs/POO.

Envoyé par benwit

mais là, sans avoir creusé, j'ai du mal à voir comment les langages fonctionnels s'interfacent avec l'utilisateur ? Il n'y a que des batchs/lignes de commandes ?

Le plus rapide pour te faire une idée c'est encore les blogs :
le blog de Alp, encore un blog de Alp
le blog de SpiceGuid

et on espère bientôt le blog de Cacophrène...