Two Dozens Short Lessons in Haskell

Posté par  . Modéré par trollhunter.
Étiquettes :
0
11
juin
2001
Doc
Extrait :
"Ce livre aurait pu s'appeler Little Haskeller... S'inspirant du principe qui fit le succès de Little Lisper et Little Schemer, il entraîne le lecteur dans un jeu de questions/réponses lui faisant
découvrir différentes facettes de ce langage de programmation."



















Two Dozens Short Lessons in Haskell
Auteur Rex Page
Pages 154 + 136
Rédacteur JZimm




<!-- Ceci est a mettre comme texte de la news annoncant la revue<br/> du livre -->


Ce livre aurait pu s'appeler Little Haskeller... S'inspirant du
principe qui fit le succès de Little Lisper et Little Schemer, il
entraîne le lecteur dans un jeu de questions/réponses lui faisant
découvrir différentes facettes de ce langage de programmation.


<!-- Fin du texte de la news -->





La littérature consacrée au langage Haskell est aujourd'hui certes
abondante, cependant, peu d'ouvrages offrent au novice une
introduction aussi abordable. Plutôt qu'être regroupées au sein de
grands ensembles thématiques comme il est d'usage dans ce genre de
livre, les deux douzaines de leçons proposées constituent un
enchaînement plus ou moins naturel dans l'apprentissage de Haskell. En
partant de l'incontournable "Hello World", le lecteur explore ainsi la
manipulation de listes et chaînes de caractères, qui l'amène
évidemment vers la notion de fonction et sa manipulation en Haskell
(déclaration, évaluation partielle, forme curryfiée etc...) Après
avoir dompté les listes et les fonctions, on découvre l'autre brique
fondamentale du langage : le système de typage. Là encore, les choses
s'enchaînent logiquement, chaque chapitre complète et enrichit les
précédents. Les seuls types de données vus pour le moment étant les
listes/chaînes de caractères, les tuples et les fonctions, un chapitre
particulier est consacré aux nombres. Le lecteur possède alors les
bases nécessaires pour comprendre la logique inhérente au langage
Haskell et à son modèle d'exécution : c'est ce dont parlent les
chapitres suivants. Enfin, on apprend à encapsuler les fonctions dans
des modules et à les protéger par des "gardes", tout ceci pour
programmer de manière structurée et modulaire. Les chapitres restants
abordent quelques points non vus jusqu'à présent mais facilement
compréhensibles par le lecteur à ce stade : en particulier les
entrées/sorties (voir plus loin), d'autres types numériques (les
rationnels) et la définition des types par l'utilisateur.



Le livre couvre ainsi un éventail plutôt large des différents aspects de
Haskell, en suivant invariablement un même schéma. Chaque chapitre
débute par quelques paragraphes d'explications et d'exemples
commentés, bâtis autour d'une petite application servant de
prétexte. Le niveau de complexité est ici très progressif : dans les
premiers chapitres, il s'agit de manipuler simplement des chaînes de
caractères et chercher par exemple des palindromes, plus loin, le
lecteur méditera sur un chiffre de César ou l'algorithme de Horner
pour terminer avec un petit jeu de Tic-Tac-Toe. Après cette
introduction, généralement accompagnée d'une multitude de remarques,
de notes et de rappels, le lecteur se voit poser une série de
questions calquées sur les exemples précédents : la plupart du temps,
il s'agit de donner le résultat de l'évaluation d'une expression
Haskell, ou au contraire de formuler une expression qui renvoie le
résultat attendu. La règle du jeu est simple : aucune surprise, aucun
piège, rien que l'application directe du cours ; les exemples étant
toujours choisis très informels et "terre à terre". Ainsi, le novice
ne devrait rencontrer aucune difficulté pour répondre à ces questions
et conserver un sentiment de bien maîtriser le sujet : une motivation
indispensable pour apprendre !



A la fin de chaque chapitre, les auteurs proposent une série de
questions de synthèse. Il s'agit de QCM où le lecteur devra souvent se
creuser un peu plus les méninges, mais l'esprit du livre y reste
omniprésent, y compris les nombreux clins d'oeil. Exemple : à la
question "comment Haskell représente-t-il les nombres ?", par exemple,
les réponses proposées sont "a.) en décimal b.) en binaire c.) en
hexadécimal d.) comme il veut - ce ne sont pas vos oignons"



Cette initiation à Haskell s'avère donc à la fois approfondie et très
didactique, néanmoins, certains chapitres accusent quelques
faiblesses. C'est notamment le cas de la partie consacrée aux
entrées/sorties, qui laisse une impression mitigée. A l'image du
reste du livre, elle permet au débutant de comprendre rapidement les
fonctions d'I/O disponibles en Haskell, et ce de manière toujours très
intuitive. Cependant, c'est là que le bât blesse : tout cela reste
justement trop intuitif et "pratique", on ne trouve aucune explication
des fameuses Monades sous-jacentes ! Concept théorique obscur s'il en
est, c'est pourtant ce qui rebute de manière quasi-systématique les
débutants en Haskell qui ont l'impression de "ne rien comprendre" à
l'affaire. Un chapitre consacré à ce sujet aurait réellement été
bienvenu, d'autant plus qu'une fois maîtrisées, les monades s'avèrent
être un outil d'une puissance fantastique ! Sur ce sujet, on ne
saurait trop conseiller aux intéressé(e)s de lire l'excellent article
de Philip Walder "Monads for Functional Programming" (Program Design
Calculi : Proceedings of the 1992 {M}arktoberdorf International Summer
School, Springer-Verlag 1993.) De même, l'annexe du livre propose un
ensemble de bibliothèques et extensions suggérées ou tout simplement
jugées intéressantes par les auteurs, que le lecteur est libre de
télécharger. Malheureusement, cela se résume à la documentation
générée automatiquement à partir des commentaires du code-source : un
inventaire des prototypes des fonctions accompagné de quelques
explications plus que télégraphiques. L'intention est très bonne, mais
le résultat ressemble tout de même à une véritable liste d'épicier...



Enfin, la moindre originalité de ce livre n'est certainement pas sa
présentation puisqu'il se compose en réalité de deux volumes : le
Question Book et l'Answer Book. Le premier, à mi-chemin entre un
ouvrage de cours et un cahier de TD, se suffit à lui-même et contient
tout ce dont le lecteur aura en principe besoin pour progresser et
finalement maîtriser Haskell. L'Answer Book, comme son nom l'indique,
contient les solutions aux questions et exercices posés dans le
Question Book. En pratique, on peut dire que son utilisation est
généralement facultative. Ces deux volumes étant disponibles sous
forme éléctronique, on pourra alors soit imprimer seulement le
Question Book et opter pour un apprentissage plus actif (il faudra
alors avoir souvent recours à l'ordinateur pour tester les exemples et
vérifier ses réponses), soit imprimer les deux et les relier ensemble
pour obtenir quelque chose entre un tutoriel et un manuel de
référence... Notons encore que tous les exemples et exercices du livre
sont prévus pour fonctionner avec l'interpréteur libre Hugs,
disponible gratuitement sous Linux aussi bien que sous Windows (en
standard dans la distribution Debian, entre autres). Il est également
possible d'utiliser le nouveau mode interactif du Glasgow Haskell
Compiler (version 5 ou supérieure), ces deux environnements étant très
proches en ce qui concerne leur utilisation.



Au final, on ne peut que saluer l'initiative des auteurs de cet
ouvrage. Non seulement ils proposent une initiation à Haskell à la
fois pratique, vivante et sérieuse, mais de plus, le livre est
disponible gratuitement pour un usage personnel et/ou éducatif sous
forme de fichiers Postscript. A découvrir d'urgence, donc, et bonne
programmation en Haskell !






Table des matières



  • 1.) Hello World etc.
  • 2.) Definitions
  • 3.) How to run Haskell programs
  • 4.) Computations on sequences - List comprehensions
  • 5.) Function composition and currying
  • 6.) Patterns of computation - composition, folding and mapping
  • 7.) Types
  • 8.) Function types, classes and polymorphism
  • 9.) Types of curried forms and higher order functions
  • 10.) Private definitions - the where clause
  • 11.) Tuples
  • 12.) The class of numbers
  • 13.) Iteration and the common patterns of repetition
  • 14.) Truncation sequences and lazy evaluation
  • 15.) Encapsulation - modules
  • 16.) Definitions with alternatives
  • 17.) Modules as libraries
  • 18.) Interactive keyboard input and screen output
  • 19.) Interactive programs with file input/output
  • 20.) Fractional numbers
  • 21.) Patterns as formal parameters
  • 22.) Recursion
  • 23.) Ifs, lets and unlimited interactive input
  • 24.) Algebraic types



Références




Aller plus loin

  • # Mais qu'est ce donc ?

    Posté par  . Évalué à 0.

    Je ne connais pas du tout Haskell ...

    Est ce que quelqu'un pourrait m'indiquer les principales caractéristiques de ce langage ? l'interet du truc ..

    merci d'avance !
    • [^] # Re: Mais qu'est ce donc ?

      Posté par  . Évalué à 0.

      c'est un language functionnel, plutot élégant dans sa syntaxe, avec un systeme de typage tres évolué (et parfois un peu trop stricte.) Il a beaucoup de concepts modernes implémentés en standards, par exemple l'évaluation paresseuse (lazy evaluation) qui n'évalue les parametres passés à une fonction que lorsqu'ils sont utilisés. (ca permet par exemple d'implementer et de manipuler des listes ou structures de données de taille infinie)

      http://haskell.org(...)
      • [^] # Re: Mais qu'est ce donc ?

        Posté par  (site web personnel) . Évalué à 1.

        http://haskell.org/(...)

        oui et pas haskeel.org comme c'est marqué dans la news.

        A propos du typage, que veux-tu dire par parfois un peu trop strict ?
        (En Caml, pour en arriver à etre limité par le systeme de typage, il faut vraiment sortir des trucs tordus)
      • [^] # c'est quoi un language fonctionnel ?

        Posté par  . Évalué à 0.

        et quel avantage par rapport a un language "non fonctionnel" ?
        • [^] # Re: c'est quoi un language fonctionnel ?

          Posté par  . Évalué à 0.

          Un langage fonctionnel strict comme Haskell est un langage où tout est fonction, il n'y a pas d'"instructions". Un programme est donc un ensemble de déclarations et d'équations, contrairement aux langages impératifs ( = "non fonctionnels") où un programme est une séquence d'opérations à exécuter.

          Quelques avantages :

          - c'est un langage de haut niveau. Un programme en Haskell est centré sur le problème et l'algorithme, pas sur la machine et l'exécution

          - grand pouvoir d'abstraction : par exemple, les fonctions et les expressions sont elles-mêmes des objets du langage, on peut les manipuler ou construire à l'exécution

          - "lazy evaluation" : les expressions sont calculées au moment où on en a besoin, pas au moment où l'on les déclare. Cela permet au compilateur d'optimiser l'ordre des calculs, voire de les paralléliser ou encore d'éviter des calculs coûteux si on s'aperçoit plus tard que finalement ils ne serviront pas... Sans parler du fait que ça simplifie *énormément* l'écriture du code

          - programmation modulaire : Haskell pousse naturellement le programmeur à écrire du code générique, maintenable et réutilisable, avec des interfaces bien définies. Il est strictement impossible (oui, impossible) de faire des effets de bord

          Quelques inconvénients :

          - c'est moins connu et moins intuitif, voire un peu académique. Programmer en Haskell demande généralement un travail de réflexion plus important que Java ou C

          - communauté restreinte : même si on trouve à peu près tout ce dont on a besoin pour Haskell, on est loin du nombre de bibliothèques et outils qui existent pour C par exemple

          - c'est plus lourd. Même s'il existe aujourd'hui des compilateurs performants pour ce type de langage (GHC, ObjectiveCaml...), un programme bien écrit en C a toujours des chances d'être plus efficace et plus léger, surtout pour les petites applications et/ou quand le programmeur n'est pas expérimenté
        • [^] # Re: c'est quoi un language fonctionnel ?

          Posté par  (site web personnel) . Évalué à 3.

          Petit rappel :

          Il existe deux grandes familles de langage : les langages impératifs et les autres (ou langages déclaratifs).
          haskell fait partie de cette deuxième catégorie.

          Les langages courants (comme C ou java) sont des langages impératifs, c'est à dire qu'un programme est une suite d'« impératifs » (opérations), qui sont exécutées dans un ordre précis.

          Dans la deuxième catégorie, on trouve les langage fonctionnel, mais aussi logique ou mixte (objet-fonctionnel).
          Dans ceux-ci, un programme ne doit pas être vu comme une suite d'opérations, mais comme une seule opération.

          Le langage qui va le plus loin est sans doute prolog, ou l'on écrit le résultat recherché en une suite d'assertions logiques, et non la manière de l'obtenir. C'est l'ordinateur qui se démerde derrière.

          Pour revenir aux langages fonctionnel : Ce sont des langages basés sur le lambda-calcul, mais qui apporte un degré similaire d'abstraction, qui est, à mon avis, bien plus naturelle que l'approche objet.

          Le programmeur se focalise sur le but et non sur les moyens de l'atteindre. C'est pourquoi on parle de langage déclaratif.

          Les avantages sont :
          - Une approche mathématique rigoureuse
          - Un code plus lisible et moins sujet à l'incompréhension homme-machine.

          Les inconvénients sont :
          - Une approche mathématique rigoureuse.

          Dans les langages fonctionnel, on trouve Lisp, Caml, Amanda, ...
          Mais je ne connais que Lisp, donc je ne peux rien dire sur les spécificités de Haskell.

          Pour terminer, il ya Ruby, un langage objet qui permet la programmation fonctionnelle, et qui me semble allier parfaitement les deux approches.

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.