Une introduction agréable au langage Haskell 98

Sommaire: Une introduction agréable au langage Haskell 98

Introduction
I.Introduction
Valeurs,types, et autres friandises
II.Valeurs,types, et autres friandises
II-1. Les types polymorphes
II-2. Types définis par l’utilisateur
II-2-1. Les types récursifs
II-3. Les synonymes de Type
II-2-4. Les types internes n’ont rien de particulier
II-4-1. Les compréhensions de listes et les séquences arithmétiques
II-4-2. Chaînes de caractères
Les Fonctions
III.Les Fonctions
III-1. Les abstractions lambda
III-2. Opérateurs infixes
III-2-1. Sections
III-2-2. Les déclarations de fixité
III-3. Les fonctions sont non-strictes
III-4. Les structures de données »infinies »
III-5. La fonction d’erreur
Les Expressions Case et la correspondance de motifs
IV. Les Expressions Case et la correspondance de motifs
IV-1. La sémantique des correspondances de motifs
IV-2. Un exemple
IV-3. Les expressions casuelles(Case expressions)
IV-4. Les motifs paresseux (Lazy-patterns)
IV-5. Cadrage lexical et forme semboîtées
IV-6. Mise en forme
Les Classes de types et la surcharge
V. Les classes de types et la surcharge
Les types,encore
VI. Les types, encore
VI-1. La déclaration new type
VI-2. Les étiquettes de champs
VI-3. Les constructeurs stricts de données
Entrées/Sorties
VII.Entrées/Sorties
VII-1. Opérations d’E/Sdebase
VII-2. Programmer avec des actions
VII-3. Gestion des exceptions
VII-4. Fichiers, canaux et gestionnaires
VII-5. Haskell et la programmation impérative
Les Classes standards de Haskell
VIII. Les Classes standards de Haskell
VIII-1. Classes pour l’égalité et la relation d’ordre
VIII-2. La Classe Enumeration
VIII-3. Les Classes Read et Show
VIII-4. Les Instances dérivées
Les Monades
IX.A propos des monades
IX-1. Les classes monadiques
IX-2. Les monades intégrées
IX-3. Utilisation des monades
Les Nombres
X. Les Nombres
X-1. Structure des classes numériques
X-2. Les Nombres construits
X-3. Les Conversions numériques et les surcharges de littéraux
X-4. Les Types numériques par défaut
Les Modules
XI.Les Modules
XI-1. Les Noms qualifiés
XI-2. Les Types de données abstraits
XI-3. Plus de caractéristiques
Les Pièges du typage
XII.Pièges du typage
XII-1. Let-Bound Polymorphism
XII-2. Surcharge numérique
XII-3. Les Restrictions monomorphiques
Les Tableaux
XIII.Les Tableaux
XIII-1. Les types d’indice
XIII-2. Création d’un tableau
XIII-3. Accumulation
XIII-4. Mises à jour incrémentales
XIII-5. Un exemple: la multiplication matricielle
Conclusion
XIV. Conclusion
XIV-1. Prochaine étape
XIV-2. Remerciements
Bibliographie

Extrait du cours une introduction agréable au langage Haskell 98

I.Introduction
L’objectif de ce tutoriel n’est pas d’apprendre à programmer, ni même d’apprendre la programmation fonctionnelle. Ca doit plutôt être un supplément au Haskell Report [4], qui fait, de toute manière, une présentation très complète et très technique. Notre objectif est de faire une légère introduction à Haskell pour quelqu’un qui a déjà une expérience avec au moins un autre langage, de préférence un langage fonctionnel (même si ce n’est qu’un langage « quasiment fonctionnel » comme ML ou Scheme). Si le lecteur souhaite en apprendre davantage au sujet de la programmation fonctionnelle, nous recommandons fortement l’ouvrage de Bird Introduction to Functional Programming ou bien celui de Davie : An Introduction to Functional Programming Systems Using Haskell [2]. Pour une étude approfondie des langages de programmation fonctionels et des techniques, incluant quelques uns des principes de la théorie des langages,voir.
Le langage Haskell a beaucoup évolué depuis sa création en 1987. Ce tutoriel utilisera Haskell 98. Les anciennes versions de ce langage sont maintenant obsolètes; les utilisateurs de Haskell sont encouragés à utiliser Haskell 98. Il y a aussi beaucoup d’extensions à Haskell 98 qui ont été implémentées. Elles ne font pas, à proprement parler, partie du langage Haskellet ne sont pas couvertes par ce tutoriel.
II.Valeurs,types, et autres friandises
Parce qu’Haskell est un langage purement fonctionnel, tous les calculs sont fait via l’évaluation d’expressions (terme syntaxique) qui retournent des valeurs (entités abstraites que l’on considère comme des réponses). À chaque valeur est associé un type (intuitivement, on peut se représenter les types comme des ensembles de valeurs). Les expressions peuvent être des valeurs atomiques telles que l’entier 5, le caractère ‘a’, ou la fonction \x -> x+1, mais elles peuvent aussi être des valeurs structurées telle que la liste [1,2,3] ou la pair(‘b’,4).
De même que les expressions dénotent des valeurs, les expressions de type sont des termes syntaxiques qui dénotent des valeurs de type (ou, plus simplement, des types). Les expressions de type peuvent être des types atomiques tels que Integer (l’ensemble infini des entiers), Char (les caractères) ou Integer->Integer (les fonctions qui, à un Interger associent un Integer), mais elles peuvent aussi être des types structurés tel que [Integer] (liste homogène d’entiers) ou (Char,Integer) (les paires composées d’un caractère et d’un entier).
II-1. Les types polymorphes
Haskell intègre également les types polymorphes, c’est-à-dire des types qui sont universellement quantifiés d’une certaine manière pour tous les types. Les expressions de type polymorphes décrivent essentiellement des familles de types. Par exemple, (forall a)[a] est la famille de types qui comprend, pour tout type a, le type de listes de a. Les listes d’entiers (p. ex. [1,2,3]), les listes de caractères (p. ex. [‘a’,’b’,’c’]), et même les listes de listes d’entiers (p. ex. [[1,2,3],[4,5,6]]), etc. sont toutes membres de cette famille. (Notons, toutefois, que [2,’b’] n’est pas un exemple valide, puisqu’il n’existe pas de type simple contenant à la fois 2 et ‘b’.)
[Les identificateurs tel que a ci-dessus sont appelés variables de type, et sont en minuscules pour les distinguer des types spécifiques tel que Int. De plus, puisque Haskell utilise uniquement des types universellement quantifiés, il n’est pas nécessaire d’écrire explicitement le symbole de la quantification universelle, et donc, dans l’exemple ci- dessus, nous écrivons simplement [a]. En d’autres termes, toutes les variables de type utilisent implicitement une quantification universelle.]
………

Lire sur cLicours.com :  Cours Haskell: Paresse, ordre strict et typage fort

Si le lien ne fonctionne pas correctement, veuillez nous contacter (mentionner le lien dans votre message)
Une introduction agréable au langage Haskell 98 (543 Ko)  (Cours PDF)
Langage Haskell

Télécharger aussi :

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.