Pourquoi utiliser (aussi) des langages fonctionnels au lycée ?

Pourquoi utiliser (aussi) des langages fonctionnels au lycée ?
Extrait du Les nouvelles technologies pour l'enseignement des mathématiques
http://revue.sesamath.net/spip.php?article216
Pourquoi utiliser (aussi) des
langages fonctionnels au lycée
?
- N°15 - Mai 2009 -
Date de mise en ligne : dimanche 24 mai 2009
Description :
Cet article a été repris dans Repères-Irem n° 81
Les nouvelles technologies pour l'enseignement des mathématiques
Copyright © Les nouvelles technologies pour l'enseignement des mathématiques Page 1/18

Pourquoi utiliser (aussi) des langages fonctionnels au lycée ?
L'algorithmique fait une entrée remarquée dans le nouveau programme de Seconde. Il y est
fait clairement mention de l'apprentissage de l'affectation, des entrées-sorties et des boucles
comme allant de soi, ce qui sous-entend que seule existe la programmation impérative.
Cependant la programmation fonctionnelle est une alternative beaucoup plus proche des
mathématiques et de leur enseignement dans le secondaire. Nous verrons dans quelle mesure
l'enseignement de l'algorithmique via les langages fonctionnels est moins perturbante pour
l'élève et le professeur n'ayant pas reçu de formation récente en algorithmique.
Cet article a été repris dans Repères-Irem n° 81
I. Programmation impérative / Programmation fonctionnelle
I.1 Conventions
L'objet de cet article n'est pas d'envisager ces deux modes de programmation avec le point de vue de l'informaticien
cherchant la méthode la plus rapide mais avec celui d'un professeur de mathématiques s'adressant à des élèves
débutants dans ce domaine [1]. Nous ne parlerons pas d'un logiciel en particulier. Cependant, pour les applications
pratiques, nous utiliserons XCAS [2], logiciel multifonctions spécialement conçu pour être utilisé en classe de
mathématiques et OCAML [3], logiciel utilisant la programmation fonctionnelle.
I.2 Programmation impérative
La programmation impérative est la plus répandue (Fortran, Pascal, C,...) et la plus proche de la machine réelle. Son
principe est de modifier à chaque instant l'état de la mémoire via les affectations. Ce mode de programmation
présente plusieurs défauts pour un lycéen :
- il s'éloigne des mathématiques en utilisant l'affectation comme base de programmation. Une même variable peut
prendre des valeurs tout à fait différentes selon le moment où on l'évalue alors qu'un élève de seconde découvre les
fonctions qui à un nombre donné associe une unique image ;
- la mémoire est constamment modifiée par le programme : le programmeur doit à chaque instant connaître son état
pour savoir ce que représentent les variables affectées ;
- on est obligé de créer des variables temporaires pour que certaines zones de la mémoire restent dans un certain
état : cela est source de nombreux bogues dus à une mauvaise maîtrise de la chronologie des affectations.
Prenons l'exemple très simple d'un programme déterminant le successeur d'un entier. Une case mémoire nommée n
reçoit comme valeur 1 :
n:=1:;
Écrivons une fonction plus_n qui ajoute k à n :
Copyright © Les nouvelles technologies pour l'enseignement des mathématiques Page 2/18

Pourquoi utiliser (aussi) des langages fonctionnels au lycée ?
plus_n(k):={
n:=n+k;
return(n);
}:;
Alors plus_n(3)renvoie 4 et si on demande à nouveau plus_n(3) on obtient 7.
Ainsi plus_n n'est pas une fonction au sens mathématique car 3 peut avoir des images distinctes ! Bien sûr, il existe
des moyens d'y remédier. Par exemple :
n:=1:;
plus_n_bis(k):={
local temp;
temp:=n+k;
return(temp);
}:;
Cette fois plus_nbis(3) renvoie toujours 4 grâce à l'affectation locale donc provisoire de la mémoire sous l'étiquette
temp. Il s'agit d'une subtilité informatique qui pourrait sembler difficile à assimiler par tous les élèves de Seconde mais
qui est souvent le préalable à toute démarche de programmation impérative. Vu sous cet angle, les efforts
nécessaires à l'enseignement de la notion d'affectation ne semblent pas servir la cause mathématique... L'algorithme
ici est cependant fort simple et nous aurions pu nous passer d'affectation :
n:=1:;
plus_n(k):={
return(n+k);
}:;
Dans la plupart des cas, ce genre d'algorithme sera englobé dans un algorithme plus complexe et on ne pourra se
passer d'affectation si on garde une démarche impérative comme nous le verrons dans les exemples suivants.
1.3 Programmation fonctionnelle
Les langages fonctionnels bannissent totalement les affectations. Ils utilisent des fonctions au sens mathématique du
terme, c'est-à-dire qu'une fonction associe une unique valeur de sortie à une valeur donnée en entrée. Les effets
négatifs listés précédemment disparaissent donc. Les fonctions peuvent être testées une par une car elles ne
changent pas selon le moment où elles sont appelées dans le programme. On parle de transparence référentielle. Au
contraire, une procédure avec effets de bord ne dépend pas uniquement des arguments entrés et donc peut changer
de comportement au cours du programme.
Copyright © Les nouvelles technologies pour l'enseignement des mathématiques Page 3/18

Pourquoi utiliser (aussi) des langages fonctionnels au lycée ?
La récursivité est le mode habituel de programmation avec de tels langages : il s'agit de fonctions qui s'appellent
elles-mêmes. Pendant longtemps, la qualité des ordinateurs et des langages fonctionnels n'était pas suffisante et
limitaient les domaines d'application de ces langages. La notion de récursion n'était jusqu'à maintenant pas au
programme de Seconde mais apparaît maintenant dans le thème « phénomènes d'évolution ».
Si nous reprenons notre exemple précédant, nous pouvons faire exprimer aux élèves que l'entier suivant n est égal à
1+ l'entier suivant n  1 : on ne sort pas des limites du cours de mathématiques et on n'a pas besoin d'introduire des
notions d'informatique en travaillant sur cette notion.
On peut écrire un algorithme ainsi :
si n = 0 alors
1
sinon
1+ successeur de n - 1
Algorithme 1 : successeur d'un entier - version récursive
La récursivité n'est pas l'apanage des langages fonctionnels. Par exemple XCAS permet d'écrire des programmes
récursifs :
plus_1_rec(k):={
if(k==0){1}
else{1+plus_1_rec(k-1)}
}:;
Pas de problème pour plus_1_rec(700) mais plus_1_rec(7000) dépasse les possibilités de calcul du logiciel. Et oui,
un langage impératif ne traite pas efficacement le problème de pile, c'est pourquoi pendant longtemps seuls les
algorithmes impératifs ont prévalus.
Remarque : par défaut, XCAS s'arrête au bout de 50 niveaux de récursion. Pour aller plus loin, il faut cliquer sur
config à côté de save. Régler alors la fenêtre recurs à 1000 par exemple.
Utilisons à présent le langage fonctionnel CAML, développé par l'INRIA [4] . Même s'il intègre des aspects impératifs
pour faciliter l'écriture de certains algorithmes, il est en premier lieu un langage fonctionnel qui en particulier gère très
efficacement la mémoire de l'ordinateur pour éviter sa saturation lors d'appels récursifs.
# let rec plus_1_rec(k)=
if k=0 then 1
else 1+plus_1_rec(k-1);;
Alors par exemple :
# plus_1_rec(36000);;
- : int = 36001
Copyright © Les nouvelles technologies pour l'enseignement des mathématiques Page 4/18

Pourquoi utiliser (aussi) des langages fonctionnels au lycée ?
Mais
# plus_1_rec(3600000);;
Stack overflow during evaluation (looping recursion?).
La pile où sont stockés les résultats intermédiaires créés par la récursion est en effet saturée. Aujourd'hui, les
langages fonctionnels sont très efficaces et gèrent de manière intelligente la pile. Ils le font soit automatiquement, soit
si la fonction utilise une récursion terminale, c'est-à-dire si l'appel récursif à la fonction n'est pas enrobé dans une
autre fonction. Ici, ce n'est pas le cas car l'appel récursif plus_1_rec(k-1) est enrobé dans la fonction x -> 1 + x. On
peut y remédier en introduisant une fonction intermédiaire qui sera récursive terminale :
# let rec plus_1_rec_temp(k,resultat)=
if k=0 then resultat
else plus_1_rec_temp(k-1,resultat+1);;
puis on appelle cette fonction en prenant comme résultat de départ 1 :
# let plus_1_rec_bis(k)=
plus_1_rec_temp(k,1);;
Alors :
# plus_1_rec_bis(360000000);;
- : int = 360000001
Il n'y a donc aucun problème pour traiter 360 millions d'appels récursifs ! Dans un premier temps, en Seconde, on
peut laisser de côté ce problème de récursion terminale et se contenter de travailler sur de petits entiers.
Ainsi, on peut choisir de travailler avec CAML ou XCAS par exemple, même si ce dernier n'est pas un langage
fonctionnel.
2 Comparaison impératif/récursif : quelques exemples
2.1 Suites
La relation $u_{n+1} = 3u_n + 2$ valable pour tout entier naturel $n$ et la donnée de $u_0 = 5$ constituent un
algorithme de calcul récursif de tout terme de la suite $(u_n)$. De telles suites peuvent être rencontrées dans le
thème d'étude « phénomènes d'évolution ». Sa traduction dans des langages sachant plus ou moins traiter de tels
algorithmes est directe. Par exemple, en XCAS cela devient :
Copyright © Les nouvelles technologies pour l'enseignement des mathématiques Page 5/18