Epreuve intégrée : La Programmation Fonctionnelle

Epreuve intégrée : La Programmation Fonctionnelle
EPFC | Bashevkin Nathan & Polazzi Fabio
2007
1

Epreuve intégrée : La Programmation Fonctionnelle
EPFC | Bashevkin Nathan & Polazzi Fabio
2007
2
Introduction ........................................................................................................................ 3
Le Cours ......................................................................................................................... 4
1. Définition simple ........................................................................................................ 5
2. Programmation impérative et fonctionnelle ............................................................. 5
La programmation impérative : .............................................................................................. 5
La programmation fonctionnelle : ........................................................................................... 5
3. Attributs de la programmation fonctionnelle ............................................................ 6
La transparence référentielle : ................................................................................................. 6
Fonctions d’ordre supérieur : .................................................................................................. 7
4. Présentation de quelques langages connus .............................................................. 7
Haskell : ..................................................................................................................................... 7
Erlang :....................................................................................................................................... 8
Miranda : ................................................................................................................................... 8
Lisp : ........................................................................................................................................... 9
5. Haskell ...................................................................................................................... 10
Premiers pas ............................................................................................................................ 11
Les types simples ..................................................................................................................... 11
Les fonctions ............................................................................................................................ 12
Evaluation paresseuse ............................................................................................................. 14
Structures de données ............................................................................................................. 15
a. Liste : ..........................................................................................................................................15
b. Queue : .......................................................................................................................................22
c. Arbre binaire: .............................................................................................................................24
d. Graphe : ......................................................................................................................................25
e. Pile ..............................................................................................................................................26
Quelques opérateurs importants ........................................................................................... 28
Le programme .............................................................................................................. 31
6. Programme : Algorithme de Dijkstra ...................................................................... 32
Fin ................................................................................................................................... 42
Conclusion ........................................................................................................................ 43
Appendice ......................................................................................................................... 44
Bibliographie .................................................................................................................... 45

Epreuve intégrée : La Programmation Fonctionnelle
EPFC | Bashevkin Nathan & Polazzi Fabio
2007
3
Introduction
Dans le cadre de notre travail de fin d’études, nous avons décidé de vous parler de la
programmation fonctionnelle. Nous avons choisi ce sujet afin de compléter notre
répertoire de types de langage informatiques. En effet, la programmation fonctionnelle
est une des trois grandes familles de langages, avec les langages orientés objets (Java,
C++) et les langages impératifs (Pascal, Perl, Assembleur), que nous avons étudié durant
ces trois années.
Notre objectif est de « vulgariser » la programmation fonctionnelle. Pour cela, notre
travail se divise en deux parties :
- Un cours, que vous êtes libres de réutiliser pour une nouvelle matière
- Un programme, afin d’illustrer concrètement ce qu’est la programmation
fonctionnelle
Notre cours se divise lui-même en deux parties.
Premièrement, nous présenterons la programmation fonctionnelle en général, ses
caractéristiques, ainsi que les principaux langages existants.
Deuxièmement, nous étudierons ensemble un langage particulier : Haskell. C’est le
langage que nous avons utilisé pour notre programme. Il est probablement le langage le
plus adapté pour la pédagogie, grâce à ses nombreuses documentations. Nous verrons les
fonctions principales utilisés en informatique et leur implémentation en Haskell, et les
structures de données tels que les piles, les listes, les arbres… Le tout sera illustré par des
exemples.
Concernant le programme, nous avons réalisé un « jeu » (qui n’est pas très drôle) qui
utilise l’algorithme de Dijkstra. Ce jeu consiste en un parcours minimal d’une case d’un
échiquier à une autre, par un cavalier. Le très renommé algorithme de Dijkstra est bien
sûr utilisé pour calculer le coût minimal d’un trajet.
Notre travail a été réparti comme suit :
Fabio
Programmation impérative et fonctionnelle, Présentation de quelques langages connus
(Haskell, Erlang), Haskell (Listes, Graphe et Arbres), Algorithme de Dijkstra
Nathan
Attributs de la programmation fonctionnelle, Présentation de quelques langages connus
(Miranda, Lisp), Haskell (Listes, Queues et Piles), Algorithme de Dijkstra
Sans plus tarder, commençons par une définition simple.

Epreuve intégrée : La Programmation Fonctionnelle
EPFC | Bashevkin Nathan & Polazzi Fabio
2007
4
Le Cours

Epreuve intégrée : La Programmation Fonctionnelle
EPFC | Bashevkin Nathan & Polazzi Fabio
2007
5
1. Définition simple
La programmation fonctionnelle est, comme son nom l’indique, une façon de
programmer au moyen de fonctions mathématiques : il faut respecter des notions de
logique mathématique. Un concept fondamental est l’abstraction. Il faut aborder un
problème complexe en le divisant en éléments plus simples et en ignorant les détails.
La programmation fonctionnelle rassemble une famille de langages très proches entre
eux. Elle regroupe des langages interprétés, c’est-à-dire que les instructions sont lues au
fur et à mesure de l’exécution.
2. Programmation impérative et fonctionnelle
Nous allons comparer deux types différents de programmation.
La programmation impérative :
On travaille sur la mémoire centrale, grâce à une succession d’instructions qui modifient
son état au moyen d’assignations. On peut représenter l’évolution du programme à
chaque instant en regardant la mémoire centrale, comme nous l’avons fait en première
année au cours de LAPR.
Dans un souci d’économie de mémoire, plusieurs techniques sont disponibles, notamment
la portée définie d’une variable. L’espace mémoire alloué à une variable locale n’est pas
définitif. Il pourra être réalloué au fil de l’exécution. Cependant, il arrive que le
programmeur veuille modifier une variable définie ailleurs dans son programme, pour
qu’elle soit dans un état précis. On appelle ces modifications « effets de bord » (side
effects). Ces effets de bord sont responsables de nombreux bugs, et compliquent la
compréhension du programme.
La programmation fonctionnelle :
La programmation fonctionnelle s’affranchit des effets de bord (et des problèmes qui
l’accompagnent !). L’avantage d’une absence d’effet de bord est la lisibilité ainsi que la
facilité à tester les fonctions séparément.
Le programme peut être vu comme un emboîtement de plusieurs fonctions indépendantes
les unes par rapport aux autres. Ces fonctions, que l’on nomme grossièrement « boite
noire », peuvent posséder plusieurs paramètres en entrée, mais qu’un seul paramètre en
sortie. Le programme est donc une application, au sens mathématique, qui ne renvoie